java集合

2018-09-10 01:02:42来源：博客园阅读 ()

存储对象可以用数组和集合

数组存对象的特点：一旦创建，其长度不可变；真实的数组存放的对象的个数未知。

集合

1、collection中定义的常用方法

 1 public class TestCollection
 2 {
 3     @Test
 4     public void testCollection1()
 5     {
 6         Collection coll = new ArrayList<>();
 7         System.out.println(coll.size());
 8         coll.add(123);
 9         coll.add(new Date());
10         System.out.println(coll.size());
11         Collection coll1 = Arrays.asList(1, 2, 3);
12         coll.addAll(coll1); // 假如coll1中所有元素
13         System.out.println(coll.isEmpty());
14         coll.clear(); // 清空
15     }
16 
17     @Test
18     public void testCollection2()
19     {
20         Collection coll = new ArrayList<>();
21         System.out.println(coll.size());
22         coll.add(123);
23         coll.add(new Date());
24         System.out.println(coll.contains(123)); // 判断集合中是否包含某元素
25         coll.add(new Person("ff", "tt"));
26         coll.contains(new Person("ff", "tt")); // 要重写Person类中的equals方法，否则比较的是地址，返回false。
27         Collection coll1 = Arrays.asList(1, 2, 3);
28         coll.retainAll(coll1); // 求两个集合中的共有元素，返回给当前集合
29         coll.remove(123); // 删除集合中元素，删除成功，返回true
30         coll.removeAll(coll1); // 从coll 中拿掉和coll1共有的元素
31         Object[] arr = coll.toArray();// 将集合转化成数组
32         Iterator iterator = coll.iterator(); // 返回一个iterator实现类的对象，用于集合遍历
33         while (iterator.hasNext())
34         {
35             System.out.println(iterator.next());
36         }
37         
38         for(Object obj:coll1){
39             System.out.println(obj); //collection可以使用增强for遍历。
40         }
41 
42     }
43 
44 }

collection 接口：

list接口存放有序的，可以重复的元素，实现类有 ArrayList、LinkedList（链表实现，对于频繁插入或者删除的操作，选择此类）、Vector（线程安全）。

set接口存放无序的，不可重复的元素实现类有 Hashset、linkedhashset、treeset

Map 接口：存储键-值对数据

hashmap、linkedhashmap、treemap、hashtable（子类：properties）

 1 public class TestList {
 2 
 3     @Test
 4     /**
 5      * list 相对于collection新增加的方法
 6      */
 7     public void testList1() {
 8         List list = new ArrayList();
 9         list.add(123);
10         list.add(new String("AAA"));
11         list.add(0, 555); //在指定索引位置添加元素
12         System.out.print(list.get(1));//获取指定位置元素
13         list.remove(0);//删除指定位置元素
14         list.set(0, 111); //设置指定位置元素
15         list.indexOf(123);//获取指定元素的位置
16         list.subList(0, 2);//截取
17     }
18 }

  1 public class TestSet {
  2 
  3     /**
  4      * set  存储的元素是无序的，不可重复的
  5      * 1、无序的：无序性！=随机性 。真正的无序性，指的是底层存储的位置是无序的
  6      * 2、不可重复性，当向set存相同元素时，后面的不能添加进去
  7      * 说明：要求添加进set中的元素的所在类，必须重写equals和hashcode的方法，进而保证元素的不可重复性，
  8      * set 中元素存储采取的是哈希算法，添加元素时，根据hashcode()，计算哈希值，将对象存到对应哈希值位置，
  9      * 若此位置已有对象存储，则通过equals（）判断两个对象是否相同，若相同，则后面一个对象不能再添加进来，若不同，则都存储在此位置。
 10      */
 11     @Test
 12     public void testHashSet() {
 13         Set set = new HashSet();
 14         set.add(3);
 15         set.add(456);
 16         set.add(null);
 17         set.add("aaa");
 18         set.add(null);
 19         set.add(new Student("aa", 12));
 20         set.add(new Student("aa", 12));
 21         System.out.print(set.size());
 22         System.out.println(set);
 23     }
 24 
 25     /**
 26      * linkedhashset 使用链表维护了一个添加进集合的顺序，遍历时是按照添加的顺序(存储仍是无序的）插入性能低于hashset
 27      */
 28     @Test
 29     public void testLinkedHashSet() {
 30         Set set = new LinkedHashSet();
 31         set.add(3);
 32         set.add(456);
 33         set.add(null);
 34         set.add("aaa");
 35         set.add(new Student("aa", 12));
 36         Iterator iterator = set.iterator();
 37         while (iterator.hasNext()) {
 38             System.out.println(iterator.next());
 39         }
 40     }
 41 
 42     /**
 43      * treeset 中添加的元素必须是同一个类的
 44      * 可以按照添加进集合的元素的指定的顺序遍历，string 、包装类默认按照从小到大顺序遍历
 45      * 向treeset添加元素时，有两种排序方法：自然排序和定制排序
 46      * 自然排序要求自定义类实现comparable接口，在重写的compareTo方法中指明按照自定义类的哪个属性排序
 47      * 向treeset添加元素时，首先按照compareto 进行比较，一旦返回0，
 48      * 虽然仅是两个对象的属性值相同，但程序会认为两个对象相同，进而后一个对象不能添加金来
 49      */
 50     @Test
 51     public void testTreeSet() {
 52         Set set = new TreeSet();
 53       /*  set.add(3);
 54         set.add(456);*/
 55         // set.add("aaa"); //运行异常
 56         set.add(new Student("aa", 12));
 57         set.add(new Student("bb", 13));
 58         for (java.lang.Object obj : set) {
 59             System.out.println(obj);
 60         }
 61     }
 62 
 63     /**
 64      * 定制排序
 65      */
 66     @Test
 67     public  void testTreeSet2(){
 68         Comparator comparator=new Comparator() {
 69             @Override
 70             public int compare(Object o1, Object o2) {
 71                 if(o1 instanceof Customer &&o2 instanceof Customer){
 72                     Customer c1=(Customer)o1;
 73                     Customer c2=(Customer)o2;
 74                     int i=  c1.getAge()-c2.getAge();
 75                     if(i==0){
 76                         return  c1.getName().compareTo(c2.getName());
 77                 }else {
 78                     return  i;
 79                     }
 80                 }
 81                 return 0;
 82             }
 83         };
 84         TreeSet set=new TreeSet(comparator);
 85         set.add(new Customer("aaa",12));
 86         set.add(new Customer("bb",13));
 87         set.add(new Customer("cc",13));
 88     }
 89 }
 90 
 91 class Student implements Comparable {
 92     private String name;
 93 
 94     private int age;
 95 
 96     public String getName() {
 97         return name;
 98     }
 99 
100     public void setName(String name) {
101         this.name = name;
102     }
103 
104     public int getAge() {
105         return age;
106     }
107 
108     public Student(String name, int age) {
109         this.name = name;
110         this.age = age;
111     }
112 
113     public void setAge(int age) {
114         this.age = age;
115     }
116 
117     public Student() {
118     }
119 
120     @Override
121     public boolean equals(Object o) {
122         if (this == o) return true;
123         if (o == null || getClass() != o.getClass()) return false;
124 
125         Student student = (Student) o;
126 
127         if (age != student.age) return false;
128         return name != null ? name.equals(student.name) : student.name == null;
129     }
130 
131     @Override
132     public int hashCode() {
133         int result = name != null ? name.hashCode() : 0;
134         result = 31 * result + age;
135         return result;
136     }
137 
138     //当treeset添加此对象时，依据此方法确定按照哪个顺序排列
139     @Override
140     public int compareTo(Object o) {
141         if (o instanceof Student) {
142             Student student = (Student) o;
143             int i = this.name.compareTo(student.name);
144             if (i == 0) {
145                 return this.age - student.age;
146             } else {
147                 return i;
148             }
149         }
150         return 0;
151     }
152 
153     
154 }
155 
156 class Customer{
157 
158     private String name;
159 
160     private int age;
161 
162     public String getName() {
163         return name;
164     }
165 
166     public void setName(String name) {
167         this.name = name;
168     }
169 
170     public int getAge() {
171         return age;
172     }
173 
174     public Customer(String name, int age) {
175         this.name = name;
176         this.age = age;
177     }
178 
179     public Customer() {
180     }
181 
182     @Override
183     public boolean equals(Object o) {
184         if (this == o) return true;
185         if (o == null || getClass() != o.getClass()) return false;
186 
187         Customer customer = (Customer) o;
188 
189         if (age != customer.age) return false;
190         return name != null ? name.equals(customer.name) : customer.name == null;
191     }
192 
193     @Override
194     public int hashCode() {
195         int result = name != null ? name.hashCode() : 0;
196         result = 31 * result + age;
197         return result;
198     }
199 }