1. import java.util.ArrayList;
   
2. import java.util.Collection;
   
3. import java.util.Iterator;
   
4. 
   
5. public class T01 {
   
6. 
   
7.         public static void main(String[] args) {
   
8.                
   
9.                 /*
   
10.                  1. 集合框架
    
11.                  Collection（接口）
    
12.                          List（接口）
    
13.                                  ArrayList
    
14.                                  LinkedList
    
15.                          Set（接口）
    
16.                                   HashSet
    
17.                  Map（接口）
    
18.                          HashMap
    
19.                  
    
20.                  2. Collection和Map的区别
    
21.                          Collection：放的就是一个一个的元素
    
22.                          Map：放的是键值对
    
23.                         
    
24.                  3. List和Set区别
    
25.                          List：可以重复，并且有序
    
26.                          Set：不可以重复，不做任何处理，就是没有序的                 
    
27.                         
    
28.                  4. ArrayList和LinkedList的区别
    
29.                          ArrayList：模拟了一个数组，他的空间是连续。
    
30.                                  他如果做删除，插入的动作的时候，效率比较低。
    
31.                                  根据索引访问数据的时候，效率比较高。
    
32.                                  遍历数据的时候，效率比较高。
    
33.                          LinkedList：是链表，他的空间不是连续。
    
34.                                  内存的空间利用率会比较高。
    
35.                                  他如果做删除，插入的动作的时候，效率比较高。
    
36.                                  根据索引访问数据的时候，效率比较低。
    
37.                                  遍历数据的时候，效率比较低。
    
38.                                  
    
39.                  5. 如果想让一个类型进行“foreach”迭代，必须实现哪一个接口？
    
40.                                  Iterable<E>
    
41. 
    
42.                  
    
43.                  6. 为什么使用泛型
    
44.                          不适用泛型的坏处：会频繁的出现类型转换
    
45.                                  类型不安全。
    
46.                                  因为会出现频繁的类型转换效率会比较低
    
47.                                  不利于程序的撰写，写程序容易出错。很多错误只能在运行时发现。
    
48.                          使用了泛型以后：
    
49.                                  因为在声明的时候就指明了他的数据类型，
    
50.                                  所以，在编译时就可以发现错误。有利于提高开发效率。
    
51.                                  因为在声明的时候就指明了他的数据类型，不会出现类型转换，
    
52.                                  他是类型安全的。
    
53.                                  
    
54.                  7. 什么叫做拆箱和装箱
    
55.                          装箱：从基本数据类型到引用类型的隐式转换
    
56.                          拆箱：从引用类型到基本数据类型的显式转换
    
57.                         
    
58.                  8. 重写equals和hashCode
    
59.                     equals比较的是地址，如果你想改变比较的逻辑
    
60.                             那么就需要重写equals。
    
61.                             重写equals就一定要重写hashCode。
    
62.                     hashCode：这一般是通过将该对象的内部地址转换成一个整数来实现的
    
63.                                  有很多集合HashTable，HashSet等等，这些集合都带了Hash这个词
    
64.                                  这个词意味着快，他为什么快，因为他会根据hashCode生成一个索引目录
    
65.                                  为了提高效率的，如果你不重写hashCode就会影响HashXXX检索的性能。
    
66.                  
    
67.                  9. Object里面常用的方法
    
68.                          hashCode()
    
69.                          toString()
    
70.                         boolean equals(Object obj)
    
71.                
    
72.                  10. Iterator<E> iterator() ：为什么要有Iterator
    
73.                          因为Collection的remove方法在迭代删除的时候不安全。
    
74.                          所以提供了iterator方法，返回迭代器。
    
75.                          通过迭代器遍历的时候删除数据是安全。
    
76.                  * */
    
77.                
    
78.                 Collection<LongCat> longCats = new ArrayList<LongCat>();
    
79.                 longCats.add(new LongCat("1001", "意大利"));
    
80.                 longCats.add(new LongCat("1002", "美国"));
    
81.                 longCats.add(new LongCat("1003", "香港"));
    
82.                 longCats.add(new LongCat("1004", "大陆"));
    
83.                
    
84.                 for (LongCat longCat2 : longCats) {
    
85.                         System.out.println(longCat2);
    
86.                 }
    
87.                
    
88.                 //看看包含不包含1002的龙猫boolean contains(Object o)  
    
89.                 boolean bln = longCats.contains(
    
90.                                 new LongCat("1002", "美国")
    
91.                                 );
    
92.                
    
93.                 System.out.println(bln);
    
94.                
    
95.                 //演示循环的时候删除数据
    
96.                 //longCats.remove(new LongCat("1002", "美国"));
    
97.                 Iterator<LongCat> it = longCats.iterator();
    
98.                 while(it.hasNext())
    
99.                 {
    
100.                         LongCat cat = it.next();
     
101.                         //it.remove();
     
102.                 }
     
103.                
     
104.                 for (LongCat longCat2 : longCats) {
     
105.                         System.out.println(longCat2);
     
106.                 }
     
107.                
     
108.                 /*
     
109.                  <T> T[]  toArray(T[] a)   
     
110.                  */
     
111.                 LongCat[] cats = new LongCat[longCats.size()];
     
112.                 LongCat[] cats2 = longCats.toArray(cats);
     
113.                 for (int i = 0; i < cats2.length; i++) {
     
114.                         System.out.println(cats2[i]);
     
115.                 }               
     
116.         }
     
117. 
     
118. }
     
119. 
     
120. class LongCat implements Comparable<LongCat>
     
121. {
     
122.         private String dna;
     
123.         public String getDna() {
     
124.                 return dna;
     
125.         }
     
126.         public void setDna(String dna) {
     
127.                 this.dna = dna;
     
128.         }
     
129.         public String getName() {
     
130.                 return name;
     
131.         }
     
132.         public void setName(String name) {
     
133.                 this.name = name;
     
134.         }
     
135.         private String name;
     
136.         public LongCat(String dna, String name) {
     
137.                 super();
     
138.                 this.dna = dna;
     
139.                 this.name = name;
     
140.         }
     
141.         @Override
     
142.         public String toString() {
     
143.                 return "LongCat [dna=" + dna + ", name=" + name + "]";
     
144.         }
     
145.         @Override
     
146.         public int hashCode() {
     
147.                 final int prime = 31;
     
148.                 int result = 1;
     
149.                 result = prime * result + ((dna == null) ? 0 : dna.hashCode());
     
150.                 return result;
     
151.         }
     
152.         @Override
     
153.         public boolean equals(Object obj) {
     
154.                 if (this == obj)
     
155.                         return true;
     
156.                 if (obj == null)
     
157.                         return false;
     
158.                 if (getClass() != obj.getClass())
     
159.                         return false;
     
160.                 LongCat other = (LongCat) obj;
     
161.                 if (dna == null) {
     
162.                         if (other.dna != null)
     
163.                                 return false;
     
164.                 } else if (!dna.equals(other.dna))
     
165.                         return false;
     
166.                 return true;
     
167.         }
     
168.         @Override
     
169.         public int compareTo(LongCat o) {
     
170.                 return o.getDna().compareTo(this.getDna());
     
171.         }
     
172. }
     

复制代码

1. import java.util.ArrayList;
   
2. import java.util.Collection;
   
3. import java.util.Iterator;
   
4. 
   
5. public class T01 {
   
6. 
   
7.         public static void main(String[] args) {
   
8.                
   
9.                 /*
   
10.                  1. 集合框架
    
11.                  Collection（接口）
    
12.                          List（接口）
    
13.                                  ArrayList
    
14.                                  LinkedList
    
15.                          Set（接口）
    
16.                                   HashSet
    
17.                  Map（接口）
    
18.                          HashMap
    
19.                  
    
20.                  2. Collection和Map的区别
    
21.                          Collection：放的就是一个一个的元素
    
22.                          Map：放的是键值对
    
23.                         
    
24.                  3. List和Set区别
    
25.                          List：可以重复，并且有序
    
26.                          Set：不可以重复，不做任何处理，就是没有序的                 
    
27.                         
    
28.                  4. ArrayList和LinkedList的区别
    
29.                          ArrayList：模拟了一个数组，他的空间是连续。
    
30.                                  他如果做删除，插入的动作的时候，效率比较低。
    
31.                                  根据索引访问数据的时候，效率比较高。
    
32.                                  遍历数据的时候，效率比较高。
    
33.                          LinkedList：是链表，他的空间不是连续。
    
34.                                  内存的空间利用率会比较高。
    
35.                                  他如果做删除，插入的动作的时候，效率比较高。
    
36.                                  根据索引访问数据的时候，效率比较低。
    
37.                                  遍历数据的时候，效率比较低。
    
38.                                  
    
39.                  5. 如果想让一个类型进行“foreach”迭代，必须实现哪一个接口？
    
40.                                  Iterable<E>
    
41. 
    
42.                  
    
43.                  6. 为什么使用泛型
    
44.                          不适用泛型的坏处：会频繁的出现类型转换
    
45.                                  类型不安全。
    
46.                                  因为会出现频繁的类型转换效率会比较低
    
47.                                  不利于程序的撰写，写程序容易出错。很多错误只能在运行时发现。
    
48.                          使用了泛型以后：
    
49.                                  因为在声明的时候就指明了他的数据类型，
    
50.                                  所以，在编译时就可以发现错误。有利于提高开发效率。
    
51.                                  因为在声明的时候就指明了他的数据类型，不会出现类型转换，
    
52.                                  他是类型安全的。
    
53.                                  
    
54.                  7. 什么叫做拆箱和装箱
    
55.                          装箱：从基本数据类型到引用类型的隐式转换
    
56.                          拆箱：从引用类型到基本数据类型的显式转换
    
57.                         
    
58.                  8. 重写equals和hashCode
    
59.                     equals比较的是地址，如果你想改变比较的逻辑
    
60.                             那么就需要重写equals。
    
61.                             重写equals就一定要重写hashCode。
    
62.                     hashCode：这一般是通过将该对象的内部地址转换成一个整数来实现的
    
63.                                  有很多集合HashTable，HashSet等等，这些集合都带了Hash这个词
    
64.                                  这个词意味着快，他为什么快，因为他会根据hashCode生成一个索引目录
    
65.                                  为了提高效率的，如果你不重写hashCode就会影响HashXXX检索的性能。
    
66.                  
    
67.                  9. Object里面常用的方法
    
68.                          hashCode()
    
69.                          toString()
    
70.                         boolean equals(Object obj)
    
71.                
    
72.                  10. Iterator<E> iterator() ：为什么要有Iterator
    
73.                          因为Collection的remove方法在迭代删除的时候不安全。
    
74.                          所以提供了iterator方法，返回迭代器。
    
75.                          通过迭代器遍历的时候删除数据是安全。
    
76.                  * */
    
77.                
    
78.                 Collection<LongCat> longCats = new ArrayList<LongCat>();
    
79.                 longCats.add(new LongCat("1001", "意大利"));
    
80.                 longCats.add(new LongCat("1002", "美国"));
    
81.                 longCats.add(new LongCat("1003", "香港"));
    
82.                 longCats.add(new LongCat("1004", "大陆"));
    
83.                
    
84.                 for (LongCat longCat2 : longCats) {
    
85.                         System.out.println(longCat2);
    
86.                 }
    
87.                
    
88.                 //看看包含不包含1002的龙猫boolean contains(Object o)  
    
89.                 boolean bln = longCats.contains(
    
90.                                 new LongCat("1002", "美国")
    
91.                                 );
    
92.                
    
93.                 System.out.println(bln);
    
94.                
    
95.                 //演示循环的时候删除数据
    
96.                 //longCats.remove(new LongCat("1002", "美国"));
    
97.                 Iterator<LongCat> it = longCats.iterator();
    
98.                 while(it.hasNext())
    
99.                 {
    
100.                         LongCat cat = it.next();
     
101.                         //it.remove();
     
102.                 }
     
103.                
     
104.                 for (LongCat longCat2 : longCats) {
     
105.                         System.out.println(longCat2);
     
106.                 }
     
107.                
     
108.                 /*
     
109.                  <T> T[]  toArray(T[] a)   
     
110.                  */
     
111.                 LongCat[] cats = new LongCat[longCats.size()];
     
112.                 LongCat[] cats2 = longCats.toArray(cats);
     
113.                 for (int i = 0; i < cats2.length; i++) {
     
114.                         System.out.println(cats2[i]);
     
115.                 }               
     
116.         }
     
117. 
     
118. }
     
119. 
     
120. class LongCat implements Comparable<LongCat>
     
121. {
     
122.         private String dna;
     
123.         public String getDna() {
     
124.                 return dna;
     
125.         }
     
126.         public void setDna(String dna) {
     
127.                 this.dna = dna;
     
128.         }
     
129.         public String getName() {
     
130.                 return name;
     
131.         }
     
132.         public void setName(String name) {
     
133.                 this.name = name;
     
134.         }
     
135.         private String name;
     
136.         public LongCat(String dna, String name) {
     
137.                 super();
     
138.                 this.dna = dna;
     
139.                 this.name = name;
     
140.         }
     
141.         @Override
     
142.         public String toString() {
     
143.                 return "LongCat [dna=" + dna + ", name=" + name + "]";
     
144.         }
     
145.         @Override
     
146.         public int hashCode() {
     
147.                 final int prime = 31;
     
148.                 int result = 1;
     
149.                 result = prime * result + ((dna == null) ? 0 : dna.hashCode());
     
150.                 return result;
     
151.         }
     
152.         @Override
     
153.         public boolean equals(Object obj) {
     
154.                 if (this == obj)
     
155.                         return true;
     
156.                 if (obj == null)
     
157.                         return false;
     
158.                 if (getClass() != obj.getClass())
     
159.                         return false;
     
160.                 LongCat other = (LongCat) obj;
     
161.                 if (dna == null) {
     
162.                         if (other.dna != null)
     
163.                                 return false;
     
164.                 } else if (!dna.equals(other.dna))
     
165.                         return false;
     
166.                 return true;
     
167.         }
     
168.         @Override
     
169.         public int compareTo(LongCat o) {
     
170.                 return o.getDna().compareTo(this.getDna());
     
171.         }
     
172. }
     

复制代码