复习java基础第四天(集合:List、Map、Collections、Enumeration)

最新推荐文章于 2021-03-21 19:57:26 发布

weixin_34365635

最新推荐文章于 2021-03-21 19:57:26 发布

阅读量99

点赞数

文章标签： java 数据库

原文链接：http://www.cnblogs.com/shellway/p/3712586.html

版权

一、List:

List 代表一个元素有序、且可重复的集合，集合中的每个元素都有其对应的顺序索引

List 允许使用重复元素，可以通过索引来访问指定位置的集合元素。

List 默认按元素的添加顺序设置元素的索引。

List 集合里添加了一些根据索引来操作集合元素的方法：

另外：

List 额外提供了一个 listIterator() 方法，该方法返回一个 ListIterator 对象，

ListIterator 接口继承了 Iterator 接口，提供了专门操作 List 的方法：

boolean hasPrevious()
Object previous()
void add()

ArrayList 和 Vector 是 List 接口的两个典型实现区别：

1、Vector 是一个古老的集合，通常建议使用 ArrayList。

2、ArrayList 是线程不安全的，而 Vector 是线程安全的。

3、即使为保证 List 集合线程安全，也不推荐使用 Vector。

 1 public class Person {
 2     
 3      private String name;
 4      private int age;
 5      
 6     public String getName() {
 7         return name;
 8     }
 9     public void setName(String name) {
10         this.name = name;
11     }
12     public int getAge() {
13         return age;
14     }
15     public void setAge(int age) {
16         this.age = age;
17     }
18     public Person(String name, int age) {
19         super();
20         this.name = name;
21         this.age = age;
22     }
23     public Person(){}
24     @Override
25     public String toString() {
26         return "Person [name=" + name + ", age=" + age + "]";
27     }  
28 }

练习代码1:Person类

 1 import java.util.ArrayList;
 2 import java.util.Comparator;
 3 import java.util.List;
 4 
 5 public class TestArrayList {
 6     public static void main(String []args){
 7         
 8         List list = new ArrayList();
 9         List list2 = new ArrayList();
10         Person p1 = new Person("lisi007",15);
11         list.add(new Person("lisi003",12));
12         list.add(new Person("lisi003",12));
13         list.add(p1);
14         list.add(new Person("lisi005",10));
15         list.add(new Person("lisi006",20));
16         
17         for(Object obj:list){
18             System.out.println(obj);
19         }
20         
21         System.out.println();
22         list2.add(new Person("zhangsan",22));
23         list2.add(new Person("zhangsan",23));
24         list.addAll(2, list2);
25         list.add(3, p1);
26     //    list.remove(1);
27         
28         System.out.println(list.indexOf(p1));
29         System.out.println(list.lastIndexOf(p1));
30         
31         for(Object obj:list){
32             System.out.println(obj);
33         }
34                 
35 /*        //遍历List方法1：调用iterator()方法
36         Iterator iterator = list.iterator();
37         while(iterator.hasNext()){
38             System.out.println(iterator.next());
39         }
40         
41         //遍历List方法2：增强for循环
42         for(Object obj:list){
43             System.out.println(obj);
44         }
45         
46         //遍历List方法3：for循环,利用get(int index)
47         for(int i=0;i<list.size();i++){
48             System.out.println(list.get(i));
49         }
50         //遍历List方法4：
51         ListIterator li = list.listIterator();
52         while(li.hasNext()){
53             System.out.println(li.next());
54         }
55 */                
56     }     
57 }

练习代码2：TestArrayList类(主程序)

二、Map:

——Map 用于保存具有映射关系的数据，因此 Map 集合里保存着两组值，一组值用于保存 Map 里的 Key，

另外一组用于保存 Map 里的 Value。

——Map 中的 key 和 value 都可以是任何引用类型的数据。

——Map 中的 Key 不允许重复（值可以），即同一个 Map 对象的任何两个 Key 通过 equals 方法比较中

返回 false。

——Key 和 Value 之间存在单向一对一关系，即通过指定的 Key 总能找到唯一的，确定的 Value。

Map常用方法：

HashMap 和 Hashtable 是 Map 接口的两个典型实现类，它们的区别：

——Hashtable 是一个古老的 Map 实现类，不建议使用。

——Hashtable 是一个线程安全的 Map 实现，但 HashMap 是线程不安全的。

——Hashtable 不允许使用 null 作为 key 和 value，而 HashMap 可以。

注意：

1、与 HashSet 集合不能保证元素的顺序的顺序一样，Hashtable 、HashMap 也不能保证其中

key-value 对的顺序。

2、Hashtable 、HashMap 判断两个 Key 相等的标准是：两个 Key 通过 equals 方法返回 true，

hashCode 值也相等。

3、Hashtable 、HashMap 判断两个 Value相等的标准是：两个 Value 通过 equals 方法返回 true。

另外：

——LinkedHashMap 是 HashMap 的子类。

——LinkedHashMap 可以维护 Map 的迭代顺序：迭代顺序与 Key-Value 对的插入顺序一致。

Properties ：

——Properties 类是 Hashtable 的子类，该对象用于处理属性文件。

——由于属性文件里的 key、value 都是字符串类型，所以 properties 里的 Key 和 Value 都是字符串类型的。

TreeMap：

1、TreeMap 存储 Key-Value 对时，需要根据 Key 对 key-value 对进行排序。

TreeMap 可以保证所有的 Key-Value 对处于有序状态。

2、TreeMap 的 Key 的排序：

——自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是

同一个类的对象，否则将会抛出 ClasssCastException。

——定制排序：创建 TreeMap 时，传入一个 Comparator 对象，该对象负责对 TreeMap 中的

所有 key 进行排序。此时不需要 Map 的 Key 实现 Comparable 接口。

练习代码：

1 url=jdbc:mysql:///test
2 driver=com.mysql.jdbc.Driver
3 user=root
4 password=123

jdbc.properties

 1 public class Person {
 2     
 3      private String name;
 4      private int age;
 5      
 6     public String getName() {
 7         return name;
 8     }
 9     public void setName(String name) {
10         this.name = name;
11     }
12     public int getAge() {
13         return age;
14     }
15     public void setAge(int age) {
16         this.age = age;
17     }
18     public Person(String name, int age) {
19         super();
20         this.name = name;
21         this.age = age;
22     }
23     public Person(){}
24     @Override
25     public String toString() {
26         return "Person [name=" + name + ", age=" + age + "]";
27     }  
28 }

Person类

 1 import java.io.FileInputStream;
 2 import java.io.FileNotFoundException;
 3 import java.io.IOException;
 4 import java.util.Collection;
 5 import java.util.Comparator;
 6 import java.util.HashMap;
 7 import java.util.Map;
 8 import java.util.Properties;
 9 import java.util.Set;
10 import java.util.TreeMap;
11 
12 public class TestHashMap {
13       public static void main(String []args) throws FileNotFoundException, IOException{
14           Map map = new HashMap();
15           
16           //添加Map元素:key不可以重复，value可以重复
17           map.put("AA", new Person("AAA",12));
18           map.put("DD", new Person("AA",12));
19           map.put("CC", new Person("CCC",13));
20           map.put("MM", new Person("MMM",15));
21           map.put("NN", new Person("AA",14));
22           
23           //遍历Map中的元素:得到键的集合通过keySet()方法
24           Set keySet = map.keySet();
25           for(Object obj:keySet){
26               Object value = map.get(obj);
27               System.out.println("key= "+obj+"  value= "+value);
28           }
29           
30           //直接得到值的集合
31           Collection values = map.values(); //这里得到的值是可以重复的
32           for(Object val:values){
33               System.out.println(val);
34           }
35           
36           //得到键值对的集合
37 /*        Map<String,Object> map = new HashMap<String,Object>();//此方法需要泛型
38           for(Map.Entry<String, Object> kv:map.entrySet()){
39               String key = kv.getKey();
40               Object value = kv.getValue();
41               System.out.println(key + " : " +value);
42           }*/
43           
44           //移除元素的
45           map.remove("DD");
46           
47           //操作Map的工具方法：
48           System.out.println(map.size());
49           System.out.println(map.isEmpty());
50           System.out.println(map.containsKey("AA"));
51           
52           Comparator comparator = new Comparator(){
53             @Override
54             public int compare(Object o1, Object o2) {
55                 int result;
56                  Person p1 = (Person) o1;
57                  Person p2 = (Person) o2;
58                  result = p1.getAge() - p2.getAge();
59                 if(result == 0){
60                     return p1.getName().compareTo(p2.getName());
61                 }
62                 return result;
63             }
64           };
65           
66           TreeMap tm = new TreeMap(comparator);
67           tm.put(new Person("ABC",12), "ABC");
68           tm.put(new Person("ABCDF",17), "ABCD");
69           tm.put(new Person("ABCDE",14), "ABCD");
70           tm.put(new Person("ABCD",14), "ABCD");
71           
72           Set c = tm.keySet();
73           for(Object keys:c){
74               Object value = tm.get(keys);
75               System.out.println(keys+"  :  "+value);
76           }
77           
78           //properties文件在java中对应的是一个properties类的对象
79           //1、创建一个properties类的对象
80            Properties properties = new Properties();
81            
82           //2、使用IO流加载对应的properties文件
83            properties.load(new FileInputStream("jdbc.properties"));
84            
85           //3、得到对应的属性值
86           String url = properties.getProperty("url");
87           System.out.println(url);              
88       }
89 }

TestHashMap类(主程序)

三、操作集合的工具类：Collections：（注意不是Collection）

1、Collections 是一个操作 Set、List 和 Map 等集合的工具类

2、Collections 中提供了大量方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象设置不可变、

对集合对象实现同步控制等方法。

排序操作：

—reverse(List)：反转 List 中元素的顺序。

—shuffle(List)：对 List 集合元素进行随机排序。

—sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序。

—sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序。

—swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换。

同步控制：

Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，

从而可以解决多线程并发访问集合时的线程安全问题。

四、Enumeration：

Enumeration 接口是 Iterator 迭代器的 “古老版本”。

练习代码：

 1 public class Person {
 2     
 3      private String name;
 4      private int age;
 5      
 6     public String getName() {
 7         return name;
 8     }
 9     public void setName(String name) {
10         this.name = name;
11     }
12     public int getAge() {
13         return age;
14     }
15     public void setAge(int age) {
16         this.age = age;
17     }
18     public Person(String name, int age) {
19         super();
20         this.name = name;
21         this.age = age;
22     }
23     public Person(){}
24     @Override
25     public String toString() {
26         return "Person [name=" + name + ", age=" + age + "]";
27     }  
28 }

Person类

 1 import java.util.ArrayList;
 2 import java.util.Collections;
 3 import java.util.Comparator;
 4 import java.util.Enumeration;
 5 import java.util.List;
 6 
 7 public class TestCollections {
 8     public static void main(String []args){
 9         
10      List list = new ArrayList();
11      list.add(new Person("lisi003",22));
12      list.add(new Person("lisi009",18));
13      list.add(new Person("lisi005",20));
14      list.add(new Person("lisi001",12));
15      
16      //使用Collection中的方法对list中和元素进行排序
17      Collections.sort( list, new Comparator() {
18         @Override
19         public int compare(Object o1, Object o2) {
20             Person p1 = (Person) o1;
21             Person p2 = (Person) o2;
22             return p1.getAge() - p2.getAge();
23         }
24     });
25      
26      for(Object obj:list){
27          System.out.println(obj);
28      }
29      
30      //获取线程安全的list对象
31      List list2 = Collections.synchronizedList(new ArrayList());
32      
33      //对Enumeration进行遍历
34      Enumeration names = Collections.enumeration(list);
35      while(names.hasMoreElements()){
36          System.out.println(names.nextElement());
37      }
38   }   
39 }

TestCollections类

转载于:https://www.cnblogs.com/shellway/p/3712586.html

weixin_34365635

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复习java基础第四天(集合:List、Map、Collections、Enumeration)

一、List:List 代表一个元素有序、且可重复的集合，集合中的每个元素都有其对应的顺序索引List 允许使用重复元素，可以通过索引来访问指定位置的集合元素。 List 默认按元素的添加顺序设置元素的索引。List 集合里添加了一些根据索引来操作集合元素的方法：另外：List 额外提供了一个 listIterator() 方法，该方法返回一个 ListIterator...
复制链接

扫一扫