黑马程序员技术交流社区

标题: 回忆以前学过的 [打印本页]

作者: 0618张军    时间: 2015-7-22 23:36
标题: 回忆以前学过的
1:数组操作(理解原理,并要求会写该算法的代码)
        1):冒泡排序原理:相邻元素两两比较,大的往后走,第一次完毕后,最大值就在最大索引处。
        2):冒泡排序代码
                public static void bubbleSort(int[] arr) {
                        // 外循环控制次数
                        for (int x = 0; x < arr.length - 1; x++) {
                                // 内循环控制每一次的比较过程
                                /*
                                 * 第一次,所有元素都参与比较,也就是0个元素不参与。
                                 *  第二次,有1个元素不用参与。
                                 *   第三次,有2个元素不用参与。 ...
                                 */
                                // -1是为了防止索引越界
                                // -x是为了减少比较的次数
                                for (int y = 0; y < arr.length - 1 - x; y++) {
                                        if (arr[y] > arr[y + 1]) {
                                                // 数据交换
                                                int temp = arr[y];
                                                arr[y] = arr[y + 1];
                                                arr[y + 1] = temp;
                                        }
                                }
                        }
                }
               
        3):查找
                --普通查找:数组无序
                --二分查找(折半查找):数组有序

        4):代码:
                public static int getIndex(int[] arr,int value)
                {
                        int maxIndex = arr.length-1;
                        int minIndex = 0;
                        int midIndex = (maxIndex+minIndex)/2;

                        while(arr[midIndex]!=value)
                        {
                                if(arr[midIndex]>value)
                                {
                                        maxIndex = midIndex - 1;
                                }
                                else if(arr[midIndex]<value)
                                {
                                        minIndex = midIndex + 1;
                                }

                                if(minIndex > maxIndex)
                                {
                                        return -1;
                                }

                                midIndex = (maxIndex+minIndex)/2;
                        }

                        return midIndex;
                }

2:Arrays工具类的使用(掌握)
        (1)Arrays是针对数组操作的工具类。
        (2)成员方法:
                public static String toString(数组):把数组变成字符串。
                public static void sort(数组):对数组进行排序(升序)。
                public static int binarySearch(int[] arr,int value):二分查找

3:System的方法(掌握)
        (1)系统类,提供了静态的变量和方法供我们使用。
        (2)成员方法:
                public static void exit(int value):退出jvm,非0表示异常退出。
                public static long currentTimeMillis():返回当前系统时间的毫秒值。(一般用来测试一个程序执行的快慢)
                        和1970 年 1 月 1 日午夜之间的时间差
                public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length):从指定源数组中复制一个数组,复制从指定的位置开始,到目标数组的指定位置结束。(了解String的的方法底层都是用的此方法即可)

4:StringBuffer(掌握)
        (1)字符个数可以发生改变的字符串类。字符串缓冲区类。
        (2)构造方法:
                A:StringBuffer():默认容量16
                B:StringBuffer(int capacity):指定容量
                C:StringBuffer(String str):把字符串转换成StringBuffer

        (3)成员方法:
                A:添加功能

                        public StringBuffer append(int i):在末尾追加元素
                         public StringBuffer insert(int index,int i):在指定位置添加元素

                B:删除功能

                        StringBuffer deleteCharAt(int index):删除指定位置字符
                        StringBuffer delete(int start, int end):删除指定开始位置和结束位置间的字符
               
                C:替换功能
                       
                        StringBuffer replace(int start, int end, String str):把开始到结束位置的字符用一个新的字符串给替换。
               
                D:截取功能

                         String substring(int start):从指定位置到末尾截取
                         String substring(int start, int end): 从指定位置到结束位置截取
                       
                E:反转功能

                        StringBuffer reverse():字符串反转

        (4)案例:
                字符串反转。
                        StringBuffer sb = new StringBuffer("abc");
                       
                        sb.reverse();
                        String result = new String(sb);
                       
                        System.out.println(result);//cba

5:基本类型包装类(掌握)
       
        (1)基本类型的数据我们只能使用值,不能做更多的操作。为了方便我们操作,java就把每种基本类型进行了包装。提供方法供我们使用。

        (2)基本类型和包装类的对应关系
                 byte                Byte
                 short                Short
                 int         Integer
                 long                Long
                 float                Float
                 double                Double
                 char        Character
                 boolean        Boolean
        (3)Integer构造方法
                A:Integer i = new Integer(int num);
                B:Integer i = new Integer(String s);
                        注意:s必须是一个由数字字符组成的字符串。
               
        (4)String和int类型的转换
                A:String -- int
                        Integer:
                                public static int parseInt(String s)
                B:int -- String
                        Integer:
                                public static String toString(int i)
                        String:
                                public static String valueOf(int i)
        (5)JDK5以后的新特性
                A:自动装箱        基本类型--引用类型
                B:自动拆箱        引用类型--基本类型

                举例:
                        Integer i = 100;// 默认相当于new Integer(100)
                        i += 200;// 等价于ii = new Integer(ii.intValue()+200);
                        //因为i += 200底层调用的是intValue()方法,所以我们要加一层判断,防止报空指针异常
                        if (i != null) {
                                i += 200;
                                System.out.println(i);
                        }
        (6)面试题:byte常量池
                Integer i1 = new Integer(127);
                Integer i2 = new Integer(127);
                System.out.println(i1 == i2);// false
                System.out.println(i1.equals(i2));// true

                Integer i3 = new Integer(128);
                Integer i4 = new Integer(128);
                System.out.println(i3 == i4);// false
                System.out.println(i3.equals(i4));// true

                Integer i5 = 128;
                Integer i6 = 128;
                System.out.println(i5 == i6);// false
                System.out.println(i5.equals(i6));// true
                //byte常量池。 byte范围内的值,直接赋值给Integer,是从常量池里面获取的。
                Integer i7 = 127;
                Integer i8 = 127;
                System.out.println(i7 == i8);// true
                System.out.println(i7.equals(i8));// true
        (7)案例:
                把字符串中的数字字符排序。
                需求:"23 98 16 38 42"
                结果:"16 23 38 42 98"
               
                代码:
                String s = "23 98 71 54 60";

                // 字符串 -- 字符串数组
                String[] strArray = s.split(" ");

                // 字符串数组 -- int数组
                int[] arr = new int[strArray.length];

                // 循环遍历赋值
                for (int x = 0; x < arr.length; x++) {
                        arr[x] = Integer.parseInt(strArray[x]);
                }
               
                //int[]排序
                Arrays.sort(arr);
               
                //把排序后的int[] -- String
                StringBuffer sb = new StringBuffer();
                for(int x=0; x<arr.length ;x++){
                        sb.append(arr[x]).append(" ");
                }
                String result = sb.toString().trim();
                System.out.println(result);







欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2