黑马程序员——java学习11（毕17--总结）——

 1 package learn;
 2 
 3 import java.util.Arrays;
 4 
 5 /*对一个字符串进行从小到大排序
 6  * 20 78 9 -7 88 36 29
 7  * 思路
 8  * 1、排序，多用int
 9  * 2、如何获取到这个字符串中的这些需要排序的数值？
10  * 发现这个字符串中其实都是空格来对数值进行分隔的
11  * 所以就想到用字符串对象的切割方法将大串变成多个小串
12  * 3、数值最终变成小字符串，怎么变成一个int数
13  * 字符串到基本类型可以使用包装类
14  * 
15  * */
16 public class WrapperDemo {
17     private static final String SPACE_SEPARATER = " ";
18     public static void main(String[] args) {
19 //        int num = 4;
20 //        num=num+5;
21 //        Integer i =4;//new Integeger(4)自动装箱 简化书写
22 //        i=i+6;
23         String numStr="20 78 9 -7 88 36 29";
24         System.out.println(numStr);
25         numStr=sortStringNumber(numStr);
26         System.out.println(numStr);
27     }
28     //用方法将步骤与主函数分开
29     public static String sortStringNumber(String numStr)
30     {
31         //1、将字符串变成字符串数组
32 //        String [] str_arr = numStr.split(" ");
33         String[] str_arr = stringToArray(numStr);
34         
35         //2、将字符串数组变成int数组
36         int[] num_arr = toIntArray(str_arr);
37         
38         
39         //3、对int数组排序
40         mySortArray(num_arr);
41         
42         //4、将排序后的int数组变成字符串
43         String temp = arrayToString(num_arr);
44         
45         return temp;
46     }
47     //1
48     public static String[] stringToArray(String numStr) {
49         //按照一个空格来吧一个字符串划分成一个个字符串，装入数组str_arr中
50         String [] str_arr = numStr.split(SPACE_SEPARATER);
51         return str_arr;
52     }
53     //2
54     private static int[] toIntArray(String[] str_arr) {
55         //字符串数组与整型数组差距就是数据内容，长度一致，所以先给出长度
56         //如果直接int[] = String[]的话只是地址间的传递
57         int[] arr = new int[str_arr.length];
58         for(int i=0;i<arr.length; i++)
59         {
60             //核心：通过parseInt将字符串转换成整型
61             arr[i] = Integer.parseInt(str_arr[i]);
62         }
63         return arr;
64     }
65     //3
66     private static void mySortArray(int[] num_arr) {
67         //排序sort
68         Arrays.sort(num_arr);
69     }
70     //4
71     private static String arrayToString(int[] num_arr) {
72         //结果要的是字符串，所以再转成字符串
73         //调用StringBuilder类的append方法，把一个个数组内容输入，再调用toString方法返回字符串
74         StringBuilder sb = new StringBuilder();
75         for(int x = 0; x<num_arr.length; x++)
76         {
77             if(x!=num_arr.length-1)
78                 sb.append(num_arr[x]+SPACE_SEPARATER);
79             else
80                 sb.append(num_arr[x]);            
81         }
82         return sb.toString();
83     }
84 }

  1 package learn;
  2 
  3 import java.util.ArrayList;
  4 import java.util.Collections;
  5 import java.util.Comparator;
  6 import java.util.List;
  7 
  8 /*
  9  * 集合框架的工具类
 10  * 对象比大小，不是compareTo就是compare
 11  * Collections: 
 12  * */
 13 
 14 public class CollectionDemo {
 15     public static void main(String[] args) {
 16 //        sortDemo();
 17 //        maxDemo();
 18         binarySearchDemo();
 19     }
 20     public static void binarySearchDemo(){
 21         List<String> list = new ArrayList<String>();
 22         list.add("abcd");
 23         list.add("aaa");
 24         list.add("zz");
 25         list.add("kkkkk");
 26         list.add("qq");
 27         Collections.sort(list);
 28         
 29         sop(list);
 30         
 31 //        int index = Collections.binarySearch(list,"aaaa");
 32         int index = halfSearch(list,"aaaa");
 33         sop("index:"+index);
 34     }
 35     
 36     public static int halfSearch(List<String> list,String key){
 37         int max,min,mid;
 38         max=list.size()-1;
 39         min=0;
 40         while(min<=max)
 41         {
 42             mid=(max+min)>>1;//    /2
 43         //获取中间角标对应元素
 44             String str = list.get(mid);
 45             //compareTo比较两个对象
 46             int num = str.compareTo(key);
 47             if(num>0)
 48                 max = mid -1;
 49             else if(num<0)
 50                 min = mid+1;
 51             else 
 52                 return mid;
 53         }
 54         //给出最佳插入位置
 55         return -min-1;
 56     }
 57     public static void maxDemo(){
 58         List<String> list = new ArrayList<String>();
 59         list.add("abcd");
 60         list.add("aaa");
 61         list.add("zz");
 62         list.add("kkkkk");
 63         list.add("qq");
 64         Collections.sort(list);
 65         sop(list);
 66         //max方法
 67         String max = Collections.max(list/*,new StrLenComparator()*/);
 68         sop("max:"+max);
 69     }
 70     public static void sortDemo()
 71     {
 72         List<String> list = new ArrayList<String>();
 73         list.add("abcd");
 74         list.add("aaa");
 75         list.add("zz");
 76         list.add("kkkkk");
 77         list.add("qq");
 78         sop(list);
 79         
 80 //        Collections.sort(list);
 81         //sort方法的，根据制定比较器，将list集合排序
 82         Collections.sort(list, new StrLenComparator());
 83         sop(list);
 84     }
 85     //输出方法简写
 86     public static void sop(Object obj)
 87     {
 88         System.out.println(obj);
 89     }
 90 }
 91 
 92 //比较器
 93 class StrLenComparator implements Comparator<String>
 94 {
 95     //重写compare方法，定义自己的规则
 96     public int compare(String s1,String s2)
 97     {
 98         if(s1.length()>s2.length())
 99             return 1;
100         if(s1.length()<s2.length())
101             return -1;
102         //调用lang包里Comparable接口的compareTo方法，与compare类似，操作对象为对象
103         return s1.compareTo(s2);
104     }
105 }

 1 package learn;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collections;
 5 import java.util.Comparator;
 6 import java.util.Iterator;
 7 import java.util.List;
 8 import java.util.TreeSet;
 9 
10 //定义比较器类
11 class StrComparator implements Comparator<String>
12 {
13     public int compare(String s1,String s2)
14     {
15         
16 //        int num = s1.compareTo(s2);
17 //        if(num>0)
18 //            return -1;
19 //        if(num<0)
20 //            return 1;
21 //        return num;    
22         return s2.compareTo(s1);
23     }
24 }
25 
26 public class CollectionsDemo2 {
27     public static void main(String[] args) {
28         orderDemo();
29     }
30     public static void orderDemo()
31     {
32         //将比较器里的规则倒叙，再调用
33         TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));
34         ts.add("abcde");
35         ts.add("aaa");
36         ts.add("kkk");
37         ts.add("ccc");
38         //迭代器
39         Iterator it = ts.iterator();
40         while(it.hasNext())
41         {
42             System.out.println(it.next());
43         }
44     }
45     
46     //替换指定
47     public static void replaceAllDemo()
48     {        
49         List<String> list = new ArrayList<String>();
50         list.add("abcd");
51         list.add("aaa");
52         list.add("zz");
53         list.add("kkkkk");
54         list.add("qq");
55         sop(list);
56         //替换
57         Collections.replaceAll(list, "aaa", "pp");
58         sop(list);
59         //反转，头和尾交换
60         Collections.reverse(list);
61         sop(list);    
62     }
63     /*
64      * fill方法可以将list集合中的所有元素替换成制定元素
65      * 将list集合中部分元素替换成指定元素
66      * */
67     //替换全部
68     public static void fillDemo()
69     {
70         List<String> list = new ArrayList<String>();
71         list.add("abcd");
72         list.add("aaa");
73         list.add("zz");
74         list.add("kkkkk");
75         list.add("qq");
76         Collections.sort(list);
77         sop(list);
78         //将集合中的元素全部替换成pp
79         Collections.fill(list, "pp");
80         sop(list);
81     }
82     public static void sop(Object obj)
83     {
84         System.out.println(obj);
85     }
86 }

 1 package learn;
 2 
 3 import java.util.Arrays;
 4 import java.util.List;
 5 
 6 /*
 7  * Arrays: 用于操作数组的工具类
 8  * 里面都是静态方法
 9  * 
10  * asList: 将数组变成List集合
11  * */
12 public class ArraysDemo {
13     public static void main(String[] args) {
14 //        int []arr = {2,4,5};
15 //        System.out.println(Arrays.toString(arr));
16         
17         //如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素
18         String [] arr = {"abc", "cc", "kkk"};
19         //把数组变成集合的好处
20         /*
21          * 可以使用集合的思想和方法来操作数组中的元素
22          * 数组变成集合，不可以使用集合的增删方法
23          * 因为数组的长度是固定的。
24          * */
25         List<String> list = Arrays.asList(arr);
26         System.out.println("contains:"+list.contains("cc"));
27 //        list.add("qq");//UnsupportedOperationException不支持操作异常
28         System.out.println(list);
29         //如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
30 //        int [] nums = {2,4,5};
31 //        List/*<int []>*/ li = Arrays.asList(nums);
32         
33         Integer [] nums = {2,4,5};
34         List<Integer> li = Arrays.asList(nums);
35         System.out.println(li);//输出一个数组的哈希值
36     }
37 }

 1 package learn;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Arrays;
 5 
 6 /*
 7  * 集合变数组
 8  * Collection接口中的toArray方法
 9  * 
10  * */
11 public class CollectionsToArray {
12     public static void main(String[] args) {
13         ArrayList<String> al = new ArrayList<String>();
14         al.add("abc1");
15         al.add("abc2");
16         al.add("abc3");
17         /*
18          * 1、指定类型的数组要定义多少
19          * 当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
20          * 当指定类型的数组长度大于了集合的size,那不会新创建了数组，而是使用传递进来的数组
21          * 所以创建一个刚刚好的数组最优。
22          * 
23          * 2、为何要将集合变数组
24          * 为了限定对元素的操作，不需要进行增删
25          * 
26          * */
27         String[] arr =al.toArray(new String[al.size()]);
28         System.out.println(Arrays.toString(arr));
29     }
30 }

 1 package learn;
 2 /*
 3  * 高级for循环
 4  * 格式:
 5  * for(数据类型 变量名 ：被遍历的集合（Collection）或者数组)
 6  * {
 7  * 
 8  * }
 9  * 对集合进行遍历
10  * 只能获取集合元素，但是不能对集合进行操作 
11  * 迭代器除了遍历，还可进行remove操作
12  * 若使用ListIterator,还可以在遍历过程中进行增删改查
13  * 
14  * 传统for循环和高级区别
15  * 高级for局限性：必须有被遍历的目标
16  * 
17  * */
18 import java.util.ArrayList;
19 import java.util.HashMap;
20 import java.util.Map;
21 import java.util.Set;
22 
23 public class ForEachDemo {
24     public static void main(String[] args) {
25         
26         ArrayList<String> al = new ArrayList<String>();
27         al.add("abc1");
28         al.add("abc2");
29         al.add("abc3");
30         //若无泛型的定义String则为Object s
31         for(String s :al)//只能对集合中元素取出，不能修改，迭代器都有remove,列表迭代器都可以增删改查
32         {
33             s="kk";
34 //            System.out.println(s);
35         }
36         System.out.println(al);
37 //        Iterator<String> it = al.iterator();
38 //        while(it.hasNext())
39 //        {
40 //            System.out.println(it.next());
41 //        }
42         int []arr = {3,5,1};
43         for(int  i :arr)
44         {
45             System.out.println("i::"+i);
46         }
47         HashMap<Integer,String> hm = new HashMap<Integer,String>();
48         hm.put(1, "a");
49         hm.put(2, "b");
50         hm.put(3, "c");
51         
52         Set<Integer> keySet = hm.keySet();
53         for(Integer i :keySet)
54         {
55             System.out.println(i+"....."+hm.get(i));
56         }
57 //        Set<Map.Entry<Integer,String>> entrySet = hm.entrySet();
58 //        for(Map.Entry<Integer, String> me: entrySet)
59         for(Map.Entry<Integer, String> me :hm.entrySet())
60         {
61             System.out.println(me.getKey()+"-------"+me.getValue());
62         }
63         
64     }
65 }

 1 package learn;
 2 /*
 3  * JDK1.5新特性
 4  * 方法的可变参数
 5  * 使用时注意：可变参数一定要定义在参数列表的最后
 6  * */
 7 public class ParamMethodDemo {
 8     public static void main(String[] args) {
 9 //        show(3,4);
10         //要定义3,4,5,6、、、、个参数的show方法时，重载方法要多个，数组法需要重新定义数组
11 //        int []arr = {2,3};
12 //        show(arr);
13 //        int[] arr1 = {2,3,4};
14 //        show(arr);
15         //可变参数，其实就是数组参数的简写方式，不用每一次都手动的建立数组对象，只要将要操作的元素作为参数传递即可
16         //隐式将这些参数封装成了数组。
17         show("haha",2,3,4,5);
18         
19     }
20     public static void show(String str,int...arr)
21     {
22         System.out.println(arr.length);
23     }
24 //    public static void show(int a,int b)
25 //    {
26 //        System.out.println(a+" "+b);
27 //    }
28 //    public static void show(int []arr)
29 //    {
30 //        System.out.println();
31 //    }
32     
33     
34 }

 1 package learn;
 2 /*
 3  * 静态导入
 4  * 当类名重名时，需要指定具体包名。
 5  * 当放大重名时，指定具备所属的对象或者类
 6  * */
 7 import java.util.Arrays;
 8 //导入的是类中的静态成员
 9 import static java.util.Arrays.*;
10 
11 public class StaticImport {
12     public static void main(String[] args) {
13         int [] arr = {3,1,5};
14         Arrays.sort(arr);
15         int index = Arrays.binarySearch(arr, 1);
16         System.out.println(Arrays.toString(arr));
17         System.out.println("index:"+index);
18     }
19 }