Javaforandroid

程序=算法（动）+数据结构（静）。

learn Javaforandroid development。主要涉及的Java基础有：instanceof 

instanceof运算符只用于对象引用变量，检查左边的被测试对象是不是右边类创建的对象，如果是，则测试结果为true，如果不是同一对象则返回false。

说明：(1)一个类的实例包括本身的实例,以及所有直接或间接子类的实例 (2)instanceof左边操作元显式声明的类型与右边操作元必须是同种类或有继承关系,  即位于继承树的同一个分支上,否则会编译出

我们知道，android类也都是典型的面向对象的类继承关系

比如控件元素，继承View类的有Button，TextView CheckBox.我们可能要用instanceof来进行类型检测。

android中，instanceof主要用于对象类型的校验，在动态生成android界面时，需要给不同的组件设置不同的颜色，监听器，这时就需要判断，这是就要用到instanceof。

主要涉及的Java基础有：arrays

一、Map


1、Map :该集合存储键值对。一对一对往里存，而且要保证键的唯一性。        和set很像。其实set底层就是使用了Map集合
|--Hashtable：底层是哈希表数据结构。不可以存入null键和null值。该集合是线程同步的。jdk1.0发布。效率低。


|--HashMap：底层是哈希表数据结构。可以存入null键和null值。该集合是线程不同步的。jdk1.2发布。效率高


|--TreeMap：底层是二叉树结构，线程不同步。可以用于给map集合中的键进行排序


2、Map的基本使用代码

[java]  view plain copy

1. import java.util.Map;  
2. import java.util.HashMap;  
3.   
4.   
5. class MapDemo   
6. {  
7.     public static void main(String[] args)   
8.     {  
9.         //创建一个容器  
10.         Map<String, String> map = new HashMap<String, String>();  
11.   
12.   
13.         //添加元素  
14.         map.put("01", "zhangsan");  
15.         map.put("02", "zhangsi");  
16.         map.put("03", "zhangwu");  
17.   
18.   
19.         //判断元素是否存在  
20.         System.out.println("containsKey:" + map.containsKey("02"));  
21.   
22.   
23.         //删除一个元素  
24.         System.out.println("remove:" + map.remove("02"));  
25.   
26.   
27.         //获取一个元素  
28.         System.out.println("get:" + map.get("03"));  
29.   
30.   
31.         //获取全部元素  
32.         System.out.println("value：" + map.values());  
33.     }  
34. }  

3。Map集合中两种取出元素的方式




Map集合的两种取出方式：
1，keySet，将map中所有的键存入到Set集合，因为set具备迭代器。
所有的迭代方式取出素偶的键，在根据get方法，获取每一个键对应的值。
在通过Set集合的迭代器取出Set集合中的键。
通过map的get(取得键值的变量)方法获取键对应的值。


第二种取出元素的方法
2.Set<Map.Entry<k,v>> endtryset; 将Map集合中的影射关系。存入到了set集合中。
而这个关系的数据类型就是Map.Entry
取出原理：就是取出map集合中的映射关系取出。这个关系就是Map.Entry; 关系对象Map.Entry获取到后，就可以通过Map.Entry
中的getKey和getValue方法获取关系中的键和值。


3.Map.Entry其实Entry也是一个接口。它是Map接口中的一个内部接口

[java]  view plain copy

1. import java.util.Set;  
2. import java.util.Map;  
3. import java.util.HashMap;  
4. import java.util.Iterator;  
5.   
6.   
7. class MapKeySet   
8. {  
9.     public static void main(String[] args)   
10.     {  
11.         //quChu_1();  
12.         quChu_2();  
13.     }  
14.   
15.   
16.     //集合的第一种取出元素方法  
17.     public static void quChu_1()  
18.     {  
19.         //定义一个Map集合的容器  
20.         Map<String, String> map = new HashMap<String, String>();  
21.         map.put("01", "zhangsan");  
22.         map.put("02", "zhangsi"); //添加元素  
23.         map.put("03", "zhangwu");  
24.         Set<String> keyset = map.keySet(); //调用keySet方法。返回一个Set类型的集合  
25.         Iterator<String> it = keyset.iterator(); //创建一个迭代器  
26.         for( ; it.hasNext(); ) //判断。只要有数据就一直运行  
27.         {  
28.             String s = it.next(); //把取出的键值赋值给变量s；  
29.             String s1 = map.get(s); //用键值通过get方法获取键值对应的名称  
30.             System.out.println(s + "     " + s1);  
31.         }  
32.     }  
33.   
34.   
35.     //取出元素的第二种方式  
36.     public static void quChu_2()  
37.     {  
38.         //定义一个Map集合的容器  
39.         Map<String, String> map = new HashMap<String, String>();  
40.         map.put("01", "zhangsan");  
41.         map.put("02", "zhangsi"); //添加元素  
42.         map.put("03", "zhangwu");  
43.         Set<Map.Entry<String, String>> entryset = map.entrySet(); //调用entrySet方法返回一个Map.Entry的映射关系  
44.         Iterator<Map.Entry<String, String>> it = entryset.iterator(); //获取迭代器  
45.         for( ; it.hasNext(); ) //判断集合中是否有元素  
46.         {  
47.             Map.Entry<String, String> ms = it.next(); //把关系对象赋值给Map.Entry集合的对象  
48.             String s1 = ms.getKey(); //获取键值  
49.             String s2 = ms.getValue(); //获取与键值对应的值  
50.             System.out.println(s1 + "      " + s2);  
51.         }  
52.     }  
53. }  

二、TreeMap的一个小应用与习题示例


/*
练习：
“sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数。


希望打印结果：a(1)c(2).....


通过结果发现，每一个字母都有对应的次数。
说明字母和次数之间都有映射关系。


注意了，当发现有映射关系时，可以选择Map集合。
因为Map集合中存放就是映射关系。


什么时候使用Map集合呢？
当数据之间存在映射关系时，就要先想Map集合。
思路：
1、将字符串转换成字符数组，因为要对每一个字母进行操作。


2、定义一个Map集合，因为打印结果的字母有顺序，所以使用TreeMap集合。


3、遍历字符数组。
将每一个字母作为键去查Map集合。
如果返回null，将该字母和1存入到Map集合中。
如果返回不是null，说明该字母在Map集合中已经存在并有对应次数。
那么就获取该粗疏并进行自增。然后将该字母和自增后的次数存入到Map集合中，覆盖调用原理键所对应的值。


4、将Map集合中的数据变成指定的字符串形式返回。
*/

[java]  view plain copy

1. import java.util.TreeMap;  
2. import java.util.Set;  
3. import java.util.Iterator;  
4. import java.util.Map;  
5.   
6.   
7. class MapTest3   
8. {  
9.     public static void main(String[] args)   
10.     {  
11.         String s = "s+fg_zx_cv*asdfxcvdf";  
12.         System.out.println(charString(s));  
13.     }  
14.   
15.   
16.     //定义一个可以查询字符串出现次数的函数  
17.     public static String charString(String str)  
18.     {  
19.         char[] chs = str.toCharArray(); //将字符串转换成字符数组  
20.         //创建集合  
21.         TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();  
22.         for(int i = 0; i < chs.length; i++)  
23.         {  
24.             Integer value = tm.get(chs[i]);  
25.             //假如不是字母就退出本次循环  
26.             if(!(chs[i] >= 'a' && chs[i] <= 'z' || chs[i] >= 'A' && chs[i] <= 'Z'))  
27.                 continue;  
28.             if(value == null)  
29.             {  
30.                 tm.put(chs[i], 1); //如果集合中没有该元素。就把该元素和1放进集合中。  
31.             }   
32.             else  
33.             {  
34.                 value = value + 1; //假如不为空，就让变量自增  
35.                 tm.put(chs[i], value); //然后把键和自增后的变量存入集合中。  
36.             }  
37.         }  
38.         //建立一个容器  
39.         StringBuffer sb = new StringBuffer();  
40.         Set<Map.Entry<Character, Integer>> entry = tm.entrySet(); //把元素存入到Set集合中  
41.         Iterator<Map.Entry<Character, Integer>> it = entry.iterator(); //建立迭代器  
42.         for( ; it.hasNext(); ) //遍历元素  
43.         {  
44.             Map.Entry<Character, Integer>  mec = it.next(); //把元素添加进Map.Entry中  
45.             Character c = mec.getKey(); //将键存入变量c中  
46.             Integer in = mec.getValue(); //将值存入变量in中  
47.             sb.append(c + "(" + in + ")"); //将键和值存入容器中。  
48.         }  
49.         return sb.toString();  
50.     }  
51.   
52.   
53. }  

三、Collections工具类
1、Collections工具类的应用一
/*
Collections的几个基本应用
Collections.sort();  //对集合进行排序
Collections.brinarySearch() //对集合中的数据进行查找
Collections.max() //查找集合中的最大值
*/

[java]  view plain copy

1. import java.util.Collections;  
2. import java.util.List;  
3. import java.util.ArrayList;  
4. import java.util.Iterator;  
5. import java.util.Comparator;  
6.   
7.   
8. class CollectionsDemo   
9. {  
10.     public static void main(String[] args)   
11.     {  
12.         listSort();  
13.     }  
14.   
15.   
16.     public static void listSort()  
17.     {  
18.         List<String> al = new ArrayList<String>(); //创建一个集合  
19.         al.add("abcd");  
20.         al.add("a"); //添加元素  
21.         al.add("abc");  
22.         al.add("efang");  
23.         al.add("ge");  
24.         Iterator<String> it = al.iterator(); //定义一个迭代器  
25.         String max = Collections.max(al, new Comp());  
26.         System.out.println("max = " + max);  
27.         for( ; it.hasNext(); ) //判断是否有元素  
28.         {  
29.             Collections.sort(al, new Comp()); //调用工具类中的sort方法。并把一个比较器但成实参传递给sort方法  
30.             System.out.println(it.next());   
31.         }  
32.         //查找某个元素所在的具体位置  
33.         //int index = Collections.binarySearch(al, "a", new Comp());  
34.         //System.out.println(index);  
35.         //调用自定义查找方法  
36.         int index1 = binarySearchDemo(al, "ge", new Comp());  
37.         System.out.println(index1);  
38.     }  
39.   
40.   
41.     public static int binarySearchDemo(List<String> ls, String key, Comparator<String> comp) //传入容器和具体要查的元素和比较器  
42.     {  
43.         int max, min, mid; //定义三个变量分别代表最大、最小、中间  
44.         max = ls.size() - 1; //计算最后一个角标的位置  
45.         min = 0; //确定最小角标的位置  
46.         while(max >= min)  
47.         {  
48.             mid = (max + min) >> 1; //计算中间角标的位置。   >>1 相当于/（除）2;  
49.             String str = ls.get(mid); //获取中间角标位置上的元素  
50.             int num = comp.compare(str, key); //判断输入的元素和中间角标位置的数是否相同  
51.             if(num > 0) //假如num大于0，说明str大于key的值  
52.                 max = mid - 1;  
53.             else if(num < 0) //假如num小于0，说明str小于key的值  
54.                 min = mid + 1;  
55.             else //反之就说明元素找到了  
56.                 return mid;  
57.         }  
58.         return -min-1; //如果没有就返回要插入的位置减一  
59.     }  
60.   
61.   
62. }  
63.   
64.   
65.   
66.   
67. //新建一个比较器，实现Comparator接口。重写compare方法  
68. class Comp implements Comparator<String>  
69. {  
70.     public int compare(String s1, String s2)  
71.     {  
72.         if(s1.length() > s2.length())  
73.             return 1;  
74.         if(s1.length() < s2.length())  
75.             return -1;  
76.         return s1.compareTo(s2);  
77.     }  
78. }  

2、Collections工具类的应用二

[java]  view plain copy

1. /* 
2. Collections.fill(List<? super T> list, T obj); //把集合中的所有元素全部替换成某个元素 
3. Collections.replaceAll(List<T> list, T oldVal, T newVal); //把集合中某个旧的元素替换成新的元素。 
4. Collections.reverse(List<?> list); //将集合元素反转 
5. */  
6. import java.util.Collections;  
7. import java.util.ArrayList;  
8.   
9.   
10. class CollectionsDemo1   
11. {  
12.     public static void main(String[] args)   
13.     {  
14.         lian();  
15.     }  
16.   
17.   
18.     public static void lian()  
19.     {  
20.         ArrayList<String> al = new ArrayList<String>();  
21.         al.add("adaf");  
22.         al.add("aaa");  
23.         al.add("bad");  
24.         al.add("bacsxd");  
25.         al.add("adr");  
26.         p("原来元素:" + al);  
27.   
28.   
29.         //Collections.fill(al, "pp");//把集合中的所有元素全部替换成某个元素  
30.         //p("替换后元素:" + al);  
31.   
32.   
33.         //Collections.replaceAll(al, "aaa", "zhangdongdong"); //把集合中某个旧的元素替换成新的元素。  
34.         //p("替换后元素:" + al);  
35.   
36.   
37.         Collections.reverse(al); //将集合元素反转  
38.         p("反转后的元素:" + al);  
39.   
40.   
41.     }  
42.   
43.   
44.     public static void p(Object obj)  
45.     {  
46.         System.out.println(obj);  
47.     }  
48.   
49.   
50. }  
51.   
52.   
53. 3、Collections工具类的应用三  
54.   
55.   
56. /* 
57. Collections.reverseOrder(); 返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。 
58. */  
59. import java.util.TreeSet;  
60. import java.util.Iterator;  
61. import java.util.Collections;  
62. import java.util.Comparator;  
63.   
64.   
65. class CollectionsDemo3   
66. {  
67.     public static void main(String[] args)   
68.     {  
69.         ni();  
70.     }  
71.   
72.   
73.     //写一个程序逆转的例子  
74.     public static void ni()  
75.     {  
76.         //把CompCom的对象当成实参传递给Collections.reverseOrder()方法。  
77.         TreeSet<String> al = new TreeSet<String>(Collections.reverseOrder(new CompCon()));  
78.         al.add("adaf"); //添加元素  
79.         al.add("adadf");  
80.         al.add("adzvafd");  
81.         al.add("favdsf");  
82.         al.add("favfssdd");  
83.         Iterator<String> it = al.iterator(); //定义迭代器  
84.         for( ; it.hasNext(); ) //遍历函数  
85.         {  
86.             String s = it.next(); //把元素赋值给变量s  
87.             System.out.println(s);  
88.         }  
89.     }  
90.   
91.   
92. }  

四、集合和数组

[java]  view plain copy

1. import java.util.Arrays;  
2. import java.util.List;  
3. import java.util.ArrayList;  
4. import java.util.Collection;  
5.   
6.   
7. class ArraysDemo   
8. {  
9.     public static void main(String[] args)   
10.     {  
11.         //array();  
12.         arrayList();  
13.     }  
14.   
15.   
16.       
17.     Arrays.asList(类型)把数组变成集合  
18.     把数组变成List集合有什么好处？  
19.     可以使用集合的思想和方法类操作数组中的元素。  
20.     注意：  
21.     将数组变成集合，不可以使用集合的增删方法。  
22.     因为数组的长度是固定的。  
23.     如果你增删，那么会发生UnsuppertedOperationException  
24.   
25.   
26.     如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接变成集合中的元素。  
27.     如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。  
28.   
29.   
30.     public static void array()  
31.     {  
32.         int[] i = {1, 3, 5};  
33.         List<int[]> li = Arrays.asList(i);  
34.         System.out.println(li); //打印结果为[[I@bdb503] 。因为是整数数组。所以把数组当成元素存入到集合中了  
35.         Integer[] in = {1, 3, 5};   
36.         List<Integer> lin = Arrays.asList(in);  
37.         System.out.println(lin); //打印结果为 {1, 3, 5};因为Integer是基本数据类。所以它定义的数组中的元素都是对象。所以集合可以存入数据。因        为集合中的数据都是对象  
38.         String[] s = {"abd", "dbc", "ade"};  
39.         List<String> ls = Arrays.asList(s);  
40.         System.out.println(ls); //打印结果为[abd, dbc, ade] 原因和Integer类一样。  
41.     }  
42.   
43.   
44.     /* 
45.     集合变数组。 
46.     Collection接口中的toArray方法。 
47.  
48.  
49.     1.指定类型的数组到底要定义多长呢? 
50.     当指定类型数组长度小于了集合的seze，那么该方法内部会创建一个新的数组，长队为集合的size 
51.     当指定类型的数组长度大于了集合的size，就不会新创建数组，二十使用传递类进来的数组。 
52.  
53.  
54.     2，为什么要将集合变成数组？ 
55.     为了限定对元素的操作。不需要对集合进行增删了。 
56.     */  
57.     public static void arrayList()  
58.     {  
59.         //定义集合  
60.         ArrayList<String> al = new ArrayList<String>();  
61.         al.add("adfd");  
62.         al.add("adf"); //添加元素  
63.         al.add("df");  
64.         String[] str = al.toArray(new String[al.size()]); //使用toArray()方法把集合变成数组  
65.         System.out.println(Arrays.toString(str)); //打印数组中的字符串形式  
66.     }  
67.   
68.   
69. }  

五、高级for循环


/*
高级for循环。
格式
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组{}


对集合进行遍历。
只能获取集合元素。但是不能对集合进行操作。


迭代器除了遍历。还可以进行remove在集合中的操作。
如果是用ListIteartor，还可以在遍历过程中看集合进行增删改查的动作。


传统for和高级for有什么区别？
高级for循环有一个局限性，必须要有要被遍历的目标
*/

[java]  view plain copy

1. import java.util.HashMap;  
2. import java.util.Map;  
3.   
4.   
5. class ForEach   
6. {  
7.     public static void main(String[] args)   
8.     {  
9.         eachFor();  
10.     }  
11.   
12.   
13.     //写一个增强for循环的函数  
14.     public static void eachFor()  
15.     {  
16.         //建一个HashMap集合  
17.         HashMap<Integer, String> hm = new HashMap<Integer, String>();  
18.         hm.put(1, "aaa");  
19.         hm.put(2, "bbb");  
20.         hm.put(3, "ccc");  
21.         for(Map.Entry<Integer, String> me : hm.entrySet())  
22.         {  
23.             System.out.println(me.getKey() + "    " + me.getValue());  
24.         }  
25.     }  
26.   
27.   
28. }  

六、可变参数


/*
JDK1.5版本出现的新特性。
方法的可变参数。
在使用时注意：可变参数一定要定义在参数列表最后面。


可变参数：
其实就是参数数组的一种简写形式。
不用每一次都手动的建立数组对象。
只要将要操作的元素作为参数传递即可。
隐式将这些参数封装成了数组。
*/

[java]  view plain copy

1. class KeBianCan   
2. {  
3.     public static void main(String[] args)   
4.     {  
5.         int[] arr = {1, 4, 6, 7, 3};  
6.         show(arr);  
7.     }  
8.       
9.     //定义一个可变参数的示例  
10.     public static void show(int... in) //其实int... in可以理解成int[] in.因为这个参数对数组的封装是隐式的。也是数组参数的简写模式  
11.     {  
12.         for(int i = 0; i < in.length; i++)  
13.         {  
14.             System.out.println(in[i]);  
15.         }  
16.     }  
17.   
18.   
19. }  

七、静态导入


静态导入。
当类名重名时，需要指定具体的包名。
如：
packa/Demo.class
packb/Demo.class


import packa.*;
import packb.*;  
如果遇到这种情况不标明类所属的包是无法准确找到类的。也就是会报错。


当方法名重名时，指定所属的对象或者类。
如：
import static java.util.Arrays.*; //导入所有类中的静态方法
 //这里必须加上类名。因为本类中本身就已经继承了Object。而Object类中就有toString()方法
 //如果不标明toString属于哪个类。就会报错
System.out.println(Arrays.ToString());一、Map


1、Map :该集合存储键值对。一对一对往里存，而且要保证键的唯一性。        和set很像。其实set底层就是使用了Map集合
|--Hashtable：底层是哈希表数据结构。不可以存入null键和null值。该集合是线程同步的。jdk1.0发布。效率低。


|--HashMap：底层是哈希表数据结构。可以存入null键和null值。该集合是线程不同步的。jdk1.2发布。效率高


|--TreeMap：底层是二叉树结构，线程不同步。可以用于给map集合中的键进行排序


2、Map的基本使用代码

[java]  view plain copy

1. import java.util.Map;  
2. import java.util.HashMap;  
3.   
4.   
5. class MapDemo   
6. {  
7.     public static void main(String[] args)   
8.     {  
9.         //创建一个容器  
10.         Map<String, String> map = new HashMap<String, String>();  
11.   
12.   
13.         //添加元素  
14.         map.put("01", "zhangsan");  
15.         map.put("02", "zhangsi");  
16.         map.put("03", "zhangwu");  
17.   
18.   
19.         //判断元素是否存在  
20.         System.out.println("containsKey:" + map.containsKey("02"));  
21.   
22.   
23.         //删除一个元素  
24.         System.out.println("remove:" + map.remove("02"));  
25.   
26.   
27.         //获取一个元素  
28.         System.out.println("get:" + map.get("03"));  
29.   
30.   
31.         //获取全部元素  
32.         System.out.println("value：" + map.values());  
33.     }  
34. }  

3。Map集合中两种取出元素的方式




Map集合的两种取出方式：
1，keySet，将map中所有的键存入到Set集合，因为set具备迭代器。
所有的迭代方式取出素偶的键，在根据get方法，获取每一个键对应的值。
在通过Set集合的迭代器取出Set集合中的键。
通过map的get(取得键值的变量)方法获取键对应的值。


第二种取出元素的方法
2.Set<Map.Entry<k,v>> endtryset; 将Map集合中的影射关系。存入到了set集合中。
而这个关系的数据类型就是Map.Entry
取出原理：就是取出map集合中的映射关系取出。这个关系就是Map.Entry; 关系对象Map.Entry获取到后，就可以通过Map.Entry
中的getKey和getValue方法获取关系中的键和值。


3.Map.Entry其实Entry也是一个接口。它是Map接口中的一个内部接口

[java]  view plain copy

1. import java.util.Set;  
2. import java.util.Map;  
3. import java.util.HashMap;  
4. import java.util.Iterator;  
5.   
6.   
7. class MapKeySet   
8. {  
9.     public static void main(String[] args)   
10.     {  
11.         //quChu_1();  
12.         quChu_2();  
13.     }  
14.   
15.   
16.     //集合的第一种取出元素方法  
17.     public static void quChu_1()  
18.     {  
19.         //定义一个Map集合的容器  
20.         Map<String, String> map = new HashMap<String, String>();  
21.         map.put("01", "zhangsan");  
22.         map.put("02", "zhangsi"); //添加元素  
23.         map.put("03", "zhangwu");  
24.         Set<String> keyset = map.keySet(); //调用keySet方法。返回一个Set类型的集合  
25.         Iterator<String> it = keyset.iterator(); //创建一个迭代器  
26.         for( ; it.hasNext(); ) //判断。只要有数据就一直运行  
27.         {  
28.             String s = it.next(); //把取出的键值赋值给变量s；  
29.             String s1 = map.get(s); //用键值通过get方法获取键值对应的名称  
30.             System.out.println(s + "     " + s1);  
31.         }  
32.     }  
33.   
34.   
35.     //取出元素的第二种方式  
36.     public static void quChu_2()  
37.     {  
38.         //定义一个Map集合的容器  
39.         Map<String, String> map = new HashMap<String, String>();  
40.         map.put("01", "zhangsan");  
41.         map.put("02", "zhangsi"); //添加元素  
42.         map.put("03", "zhangwu");  
43.         Set<Map.Entry<String, String>> entryset = map.entrySet(); //调用entrySet方法返回一个Map.Entry的映射关系  
44.         Iterator<Map.Entry<String, String>> it = entryset.iterator(); //获取迭代器  
45.         for( ; it.hasNext(); ) //判断集合中是否有元素  
46.         {  
47.             Map.Entry<String, String> ms = it.next(); //把关系对象赋值给Map.Entry集合的对象  
48.             String s1 = ms.getKey(); //获取键值  
49.             String s2 = ms.getValue(); //获取与键值对应的值  
50.             System.out.println(s1 + "      " + s2);  
51.         }  
52.     }  
53. }  

二、TreeMap的一个小应用与习题示例


/*
练习：
“sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数。


希望打印结果：a(1)c(2).....


通过结果发现，每一个字母都有对应的次数。
说明字母和次数之间都有映射关系。


注意了，当发现有映射关系时，可以选择Map集合。
因为Map集合中存放就是映射关系。


什么时候使用Map集合呢？
当数据之间存在映射关系时，就要先想Map集合。
思路：
1、将字符串转换成字符数组，因为要对每一个字母进行操作。


2、定义一个Map集合，因为打印结果的字母有顺序，所以使用TreeMap集合。


3、遍历字符数组。
将每一个字母作为键去查Map集合。
如果返回null，将该字母和1存入到Map集合中。
如果返回不是null，说明该字母在Map集合中已经存在并有对应次数。
那么就获取该粗疏并进行自增。然后将该字母和自增后的次数存入到Map集合中，覆盖调用原理键所对应的值。


4、将Map集合中的数据变成指定的字符串形式返回。
*/

[java]  view plain copy

1. import java.util.TreeMap;  
2. import java.util.Set;  
3. import java.util.Iterator;  
4. import java.util.Map;  
5.   
6.   
7. class MapTest3   
8. {  
9.     public static void main(String[] args)   
10.     {  
11.         String s = "s+fg_zx_cv*asdfxcvdf";  
12.         System.out.println(charString(s));  
13.     }  
14.   
15.   
16.     //定义一个可以查询字符串出现次数的函数  
17.     public static String charString(String str)  
18.     {  
19.         char[] chs = str.toCharArray(); //将字符串转换成字符数组  
20.         //创建集合  
21.         TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();  
22.         for(int i = 0; i < chs.length; i++)  
23.         {  
24.             Integer value = tm.get(chs[i]);  
25.             //假如不是字母就退出本次循环  
26.             if(!(chs[i] >= 'a' && chs[i] <= 'z' || chs[i] >= 'A' && chs[i] <= 'Z'))  
27.                 continue;  
28.             if(value == null)  
29.             {  
30.                 tm.put(chs[i], 1); //如果集合中没有该元素。就把该元素和1放进集合中。  
31.             }   
32.             else  
33.             {  
34.                 value = value + 1; //假如不为空，就让变量自增  
35.                 tm.put(chs[i], value); //然后把键和自增后的变量存入集合中。  
36.             }  
37.         }  
38.         //建立一个容器  
39.         StringBuffer sb = new StringBuffer();  
40.         Set<Map.Entry<Character, Integer>> entry = tm.entrySet(); //把元素存入到Set集合中  
41.         Iterator<Map.Entry<Character, Integer>> it = entry.iterator(); //建立迭代器  
42.         for( ; it.hasNext(); ) //遍历元素  
43.         {  
44.             Map.Entry<Character, Integer>  mec = it.next(); //把元素添加进Map.Entry中  
45.             Character c = mec.getKey(); //将键存入变量c中  
46.             Integer in = mec.getValue(); //将值存入变量in中  
47.             sb.append(c + "(" + in + ")"); //将键和值存入容器中。  
48.         }  
49.         return sb.toString();  
50.     }  
51.   
52.   
53. }  

三、Collections工具类
1、Collections工具类的应用一
/*
Collections的几个基本应用
Collections.sort();  //对集合进行排序
Collections.brinarySearch() //对集合中的数据进行查找
Collections.max() //查找集合中的最大值
*/

[java]  view plain copy

1. import java.util.Collections;  
2. import java.util.List;  
3. import java.util.ArrayList;  
4. import java.util.Iterator;  
5. import java.util.Comparator;  
6.   
7.   
8. class CollectionsDemo   
9. {  
10.     public static void main(String[] args)   
11.     {  
12.         listSort();  
13.     }  
14.   
15.   
16.     public static void listSort()  
17.     {  
18.         List<String> al = new ArrayList<String>(); //创建一个集合  
19.         al.add("abcd");  
20.         al.add("a"); //添加元素  
21.         al.add("abc");  
22.         al.add("efang");  
23.         al.add("ge");  
24.         Iterator<String> it = al.iterator(); //定义一个迭代器  
25.         String max = Collections.max(al, new Comp());  
26.         System.out.println("max = " + max);  
27.         for( ; it.hasNext(); ) //判断是否有元素  
28.         {  
29.             Collections.sort(al, new Comp()); //调用工具类中的sort方法。并把一个比较器但成实参传递给sort方法  
30.             System.out.println(it.next());   
31.         }  
32.         //查找某个元素所在的具体位置  
33.         //int index = Collections.binarySearch(al, "a", new Comp());  
34.         //System.out.println(index);  
35.         //调用自定义查找方法  
36.         int index1 = binarySearchDemo(al, "ge", new Comp());  
37.         System.out.println(index1);  
38.     }  
39.   
40.   
41.     public static int binarySearchDemo(List<String> ls, String key, Comparator<String> comp) //传入容器和具体要查的元素和比较器  
42.     {  
43.         int max, min, mid; //定义三个变量分别代表最大、最小、中间  
44.         max = ls.size() - 1; //计算最后一个角标的位置  
45.         min = 0; //确定最小角标的位置  
46.         while(max >= min)  
47.         {  
48.             mid = (max + min) >> 1; //计算中间角标的位置。   >>1 相当于/（除）2;  
49.             String str = ls.get(mid); //获取中间角标位置上的元素  
50.             int num = comp.compare(str, key); //判断输入的元素和中间角标位置的数是否相同  
51.             if(num > 0) //假如num大于0，说明str大于key的值  
52.                 max = mid - 1;  
53.             else if(num < 0) //假如num小于0，说明str小于key的值  
54.                 min = mid + 1;  
55.             else //反之就说明元素找到了  
56.                 return mid;  
57.         }  
58.         return -min-1; //如果没有就返回要插入的位置减一  
59.     }  
60.   
61.   
62. }  
63.   
64.   
65.   
66.   
67. //新建一个比较器，实现Comparator接口。重写compare方法  
68. class Comp implements Comparator<String>  
69. {  
70.     public int compare(String s1, String s2)  
71.     {  
72.         if(s1.length() > s2.length())  
73.             return 1;  
74.         if(s1.length() < s2.length())  
75.             return -1;  
76.         return s1.compareTo(s2);  
77.     }  
78. }  

2、Collections工具类的应用二

[java]  view plain copy

1. /* 
2. Collections.fill(List<? super T> list, T obj); //把集合中的所有元素全部替换成某个元素 
3. Collections.replaceAll(List<T> list, T oldVal, T newVal); //把集合中某个旧的元素替换成新的元素。 
4. Collections.reverse(List<?> list); //将集合元素反转 
5. */  
6. import java.util.Collections;  
7. import java.util.ArrayList;  
8.   
9.   
10. class CollectionsDemo1   
11. {  
12.     public static void main(String[] args)   
13.     {  
14.         lian();  
15.     }  
16.   
17.   
18.     public static void lian()  
19.     {  
20.         ArrayList<String> al = new ArrayList<String>();  
21.         al.add("adaf");  
22.         al.add("aaa");  
23.         al.add("bad");  
24.         al.add("bacsxd");  
25.         al.add("adr");  
26.         p("原来元素:" + al);  
27.   
28.   
29.         //Collections.fill(al, "pp");//把集合中的所有元素全部替换成某个元素  
30.         //p("替换后元素:" + al);  
31.   
32.   
33.         //Collections.replaceAll(al, "aaa", "zhangdongdong"); //把集合中某个旧的元素替换成新的元素。  
34.         //p("替换后元素:" + al);  
35.   
36.   
37.         Collections.reverse(al); //将集合元素反转  
38.         p("反转后的元素:" + al);  
39.   
40.   
41.     }  
42.   
43.   
44.     public static void p(Object obj)  
45.     {  
46.         System.out.println(obj);  
47.     }  
48.   
49.   
50. }  
51.   
52.   
53. 3、Collections工具类的应用三  
54.   
55.   
56. /* 
57. Collections.reverseOrder(); 返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。 
58. */  
59. import java.util.TreeSet;  
60. import java.util.Iterator;  
61. import java.util.Collections;  
62. import java.util.Comparator;  
63.   
64.   
65. class CollectionsDemo3   
66. {  
67.     public static void main(String[] args)   
68.     {  
69.         ni();  
70.     }  
71.   
72.   
73.     //写一个程序逆转的例子  
74.     public static void ni()  
75.     {  
76.         //把CompCom的对象当成实参传递给Collections.reverseOrder()方法。  
77.         TreeSet<String> al = new TreeSet<String>(Collections.reverseOrder(new CompCon()));  
78.         al.add("adaf"); //添加元素  
79.         al.add("adadf");  
80.         al.add("adzvafd");  
81.         al.add("favdsf");  
82.         al.add("favfssdd");  
83.         Iterator<String> it = al.iterator(); //定义迭代器  
84.         for( ; it.hasNext(); ) //遍历函数  
85.         {  
86.             String s = it.next(); //把元素赋值给变量s  
87.             System.out.println(s);  
88.         }  
89.     }  
90.   
91.   
92. }  

四、集合和数组

[java]  view plain copy

1. import java.util.Arrays;  
2. import java.util.List;  
3. import java.util.ArrayList;  
4. import java.util.Collection;  
5.   
6.   
7. class ArraysDemo   
8. {  
9.     public static void main(String[] args)   
10.     {  
11.         //array();  
12.         arrayList();  
13.     }  
14.   
15.   
16.       
17.     Arrays.asList(类型)把数组变成集合  
18.     把数组变成List集合有什么好处？  
19.     可以使用集合的思想和方法类操作数组中的元素。  
20.     注意：  
21.     将数组变成集合，不可以使用集合的增删方法。  
22.     因为数组的长度是固定的。  
23.     如果你增删，那么会发生UnsuppertedOperationException  
24.   
25.   
26.     如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接变成集合中的元素。  
27.     如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。  
28.   
29.   
30.     public static void array()  
31.     {  
32.         int[] i = {1, 3, 5};  
33.         List<int[]> li = Arrays.asList(i);  
34.         System.out.println(li); //打印结果为[[I@bdb503] 。因为是整数数组。所以把数组当成元素存入到集合中了  
35.         Integer[] in = {1, 3, 5};   
36.         List<Integer> lin = Arrays.asList(in);  
37.         System.out.println(lin); //打印结果为 {1, 3, 5};因为Integer是基本数据类。所以它定义的数组中的元素都是对象。所以集合可以存入数据。因        为集合中的数据都是对象  
38.         String[] s = {"abd", "dbc", "ade"};  
39.         List<String> ls = Arrays.asList(s);  
40.         System.out.println(ls); //打印结果为[abd, dbc, ade] 原因和Integer类一样。  
41.     }  
42.   
43.   
44.     /* 
45.     集合变数组。 
46.     Collection接口中的toArray方法。 
47.  
48.  
49.     1.指定类型的数组到底要定义多长呢? 
50.     当指定类型数组长度小于了集合的seze，那么该方法内部会创建一个新的数组，长队为集合的size 
51.     当指定类型的数组长度大于了集合的size，就不会新创建数组，二十使用传递类进来的数组。 
52.  
53.  
54.     2，为什么要将集合变成数组？ 
55.     为了限定对元素的操作。不需要对集合进行增删了。 
56.     */  
57.     public static void arrayList()  
58.     {  
59.         //定义集合  
60.         ArrayList<String> al = new ArrayList<String>();  
61.         al.add("adfd");  
62.         al.add("adf"); //添加元素  
63.         al.add("df");  
64.         String[] str = al.toArray(new String[al.size()]); //使用toArray()方法把集合变成数组  
65.         System.out.println(Arrays.toString(str)); //打印数组中的字符串形式  
66.     }  
67.   
68.   
69. }  

五、高级for循环


/*
高级for循环。
格式
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组{}


对集合进行遍历。
只能获取集合元素。但是不能对集合进行操作。


迭代器除了遍历。还可以进行remove在集合中的操作。
如果是用ListIteartor，还可以在遍历过程中看集合进行增删改查的动作。


传统for和高级for有什么区别？
高级for循环有一个局限性，必须要有要被遍历的目标
*/

[java]  view plain copy

1. import java.util.HashMap;  
2. import java.util.Map;  
3.   
4.   
5. class ForEach   
6. {  
7.     public static void main(String[] args)   
8.     {  
9.         eachFor();  
10.     }  
11.   
12.   
13.     //写一个增强for循环的函数  
14.     public static void eachFor()  
15.     {  
16.         //建一个HashMap集合  
17.         HashMap<Integer, String> hm = new HashMap<Integer, String>();  
18.         hm.put(1, "aaa");  
19.         hm.put(2, "bbb");  
20.         hm.put(3, "ccc");  
21.         for(Map.Entry<Integer, String> me : hm.entrySet())  
22.         {  
23.             System.out.println(me.getKey() + "    " + me.getValue());  
24.         }  
25.     }  
26.   
27.   
28. }  

六、可变参数


/*
JDK1.5版本出现的新特性。
方法的可变参数。
在使用时注意：可变参数一定要定义在参数列表最后面。


可变参数：
其实就是参数数组的一种简写形式。
不用每一次都手动的建立数组对象。
只要将要操作的元素作为参数传递即可。
隐式将这些参数封装成了数组。
*/

[java]  view plain copy

1. class KeBianCan   
2. {  
3.     public static void main(String[] args)   
4.     {  
5.         int[] arr = {1, 4, 6, 7, 3};  
6.         show(arr);  
7.     }  
8.       
9.     //定义一个可变参数的示例  
10.     public static void show(int... in) //其实int... in可以理解成int[] in.因为这个参数对数组的封装是隐式的。也是数组参数的简写模式  
11.     {  
12.         for(int i = 0; i < in.length; i++)  
13.         {  
14.             System.out.println(in[i]);  
15.         }  
16.     }  
17.   
18.   
19. }  

七、静态导入


静态导入。
当类名重名时，需要指定具体的包名。
如：
packa/Demo.class
packb/Demo.class


import packa.*;
import packb.*;  
如果遇到这种情况不标明类所属的包是无法准确找到类的。也就是会报错。


当方法名重名时，指定所属的对象或者类。
如：
import static java.util.Arrays.*; //导入所有类中的静态方法
 //这里必须加上类名。因为本类中本身就已经继承了Object。而Object类中就有toString()方法
 //如果不标明toString属于哪个类。就会报错
System.out.println(Arrays.ToString());