Java集合框架
<Java集合框架的四大接口>
Collection：存储无序的、不唯一的数据；其下有List和Set两大接口。
List：存储有序的、不唯一的数据；
Set：存储无序的、唯一的数据；
Map：以键值对的形式存储数据，以键取值。键不能重复，但值可以重复。
接口的常用实现类：ArrayList、LinkedList、Vector、HashSet、LinkedHashSet、TreeSet、HashMap、LinkedHashMap、TreeMap、HashTable
一、List接口
是一个有序集合，继承自Collection接口。现已知常用实现类有：ArrayList、LinkedList、Vector。
1. 常用方法：
add（）：在列表的最后添加元素；
add（index，obj）：在列表的指定位置添加元素；
size（）：返回当前列表的元素个数
get（int index）：返回下标为index的元素；
clear（）：清除列表中所有元素；
isEmpty（）：检测列表是否为空；返回true/false；
contains（）：传入一个对象，检测列表中是否含有该对象；
indexOf（）：传入一个对象，返回该对象在列表中首次出现的地址；
lastInsevOf（）：传入一个对象，返回该对象在列表中最后一次出现的地址；
remove（）：传入一个下标，或者一个对象，删除指定元素；如果删除指定对象，需要重写equals（）方法，比对传入的对象是不是属于原列表，如果属于，结果返回true；
set（index，obj）：用新传入的对象，将指定位置的元素替换掉，返回被替换前的元素对象；
subList（）：截取一个子列表返回List类型；
toArray（）：将列表转为数组，返回一个Object[]类型；
iterator（）：使用迭代器遍历。
2. 如何输出List列表？
a. for循环；
b. foreach遍历（比较常用）；
c. 使用迭代器遍历列表；
3. List接口的常用实现类：
ArrayList和LinkedList实现类是继承自List接口的，所以List的常用方法它们也是适用的。
a. ArrayList
ArrayList实现了一个长度可变的数组，在内存空间中开辟一串连续的空间。
b. LinkedList
LinkedList使用链表结构存储数据，在插入和删除元素是速度非常快。
1 //ArrayList实现类 2 ArrayList<String> list1=new ArrayList<String>(); 3 list1.add("第一条数据"); 4 list1.add("第二条数据"); 5 list1.add("第三条数据"); 6 list1.add("第四条数据"); 7 list1.add("第五条数据"); 8 list1.add("第三条数据"); 9 list1.add(2,"第六条数据"); //在第三条数据后添加“第六条数据” 10 11 System.out.println(list1.size()); //返回列表长度 12 System.out.println(list1.get(2)); //返回“第六条数据” 13 //list1.clear(); //清除所有数据 14 System.out.println(list1.isEmpty()); //返回false 15 System.out.println(list1.contains("第一条数据")); //返回true 16 System.out.println(list1.indexOf("第三条数据")); //返回3 17 System.out.println(list1.lastIndexOf("第三条数据")); //返回6 18 System.out.println(list1.remove(1)); //删除“第二条数据” 19 System.out.println(list1.set(0, "替换第一条数据")); //替换第一条数据 20 List list=list1.subList(2, 5); //截取第三到第五条数据，返回List 21 System.out.println(list1.toString()); //转成数组 22 23 //LinkedList实现类 24 LinkedList<News> list2=new LinkedList<News>(); 25 list2.add(new News(1,"xxxxxxx","赵")); 26 list2.add(new News(2,"sssssss","钱")); 27 list2.add(new News(3,"yyyyyyy","孙")); 28 list2.add(new News(4,"nnnnnnn","李")); 29 list2.add(new News(5,"rrrrrrr","周")); 30 System.out.println(list2.contains(new News(3,"yyyyyyy","孙"))); //返回为true；重写equals()方法；如果不重写equals()方法，返回为false； 31 System.out.println(list2.remove(new News(1,"xxxxxxx","赵"))); //返回为true 32 33 /* 34 * 使用for循环遍历 35 */ 36 for (int i = 0; i < list1.size(); i++) { 37 if(list1.get(i) instanceof String){ //判断传入的数据属不属于String类型 38 String str=list1.get(i); 39 System.out.println(str); 40 } 41 } 42 /* 43 * foreach遍历 44 */ 45 for (News news : list2) { 46 System.out.println(news.getId()+" "+news.getTitle()+" "+news.getAuthor()); 47 } 48 /* 49 * 迭代器遍历 50 */ 51 Iterator<String> iter=list.iterator(); 52 while(iter.hasNext()){ //判断list有没有下一条 53 String s=iter.next(); //字符串取到下一条 54 System.out.println(s); 55 } 56
1 /** 2 *News类 3 */ 4 class News{ 5 private int id; 6 private String title; 7 private String author; 8 9 @Override 10 public boolean equals(Object obj) { 11 if (this == obj) 12 return true; 13 if (obj == null) 14 return false; 15 if (getClass() != obj.getClass()) 16 return false; 17 News other = (News) obj; 18 if (author == null) { 19 if (other.author != null) 20 return false; 21 } else if (!author.equals(other.author)) 22 return false; 23 if (id != other.id) 24 return false; 25 if (title == null) { 26 if (other.title != null) 27 return false; 28 } else if (!title.equals(other.title)) 29 return false; 30 return true; 31 } 32 public News() { 33 super(); 34 } 35 public News(int id, String title, String author) { 36 super(); 37 this.id = id; 38 this.title = title; 39 this.author = author; 40 } 41 public int getId() { 42 return id; 43 } 44 public void setId(int id) { 45 this.id = id; 46 } 47 public String getTitle() { 48 return title; 49 } 50 public void setTitle(String title) { 51 this.title = title; 52 } 53 public String getAuthor() { 54 return author; 55 } 56 public void setAuthor(String author) { 57 this.author = author; 58 } 59 60 61 }
二、Set接口
1. 常用方法：
与List接口基本相同。但是Set接口中的元素是无序的，因此没有与下标有关的方法。例如：get（index）、remove（index）、add（index，obj）
2. Set接口的现已知常用实现类有：
HashSet、LinkedHashSet、TreeSet
3. HashSet
底层是HashMap的相关方法，传入数据后，根据数据的hashCode进行散列运算，得到一个散列值后再进行运算，确定元素在序列中存储的位置。
所以，使用HashSet存数据必须在实体类中重写hashCode和equals方法！！
1 //HashSet无序的 2 Set<String> set1=new HashSet<String>(); 3 set1.add("set1"); 4 set1.add("set2"); 5 set1.add("set3"); 6 set1.add("set4"); 7 set1.add("set5"); 8 9 //foreach遍历 10 for (String set : set1) { 11 System.out.println(set); 12 } 13
4. LinkedHashSet
在HashSet的基础上，新增了一个链表。用链表来记录HashSet种元素放入的顺序；HashSet依然是无序的，但链表会按照存入的顺序存储。
1 //LinkedHashSet按照放入的顺序输出 2 Set<Person> set2=new LinkedHashSet<Person>(); 3 // set2.addAll(set1); //追加set1的所有数据 4 set2.add(new Person(1,"红")); 5 set2.add(new Person(2,"黄")); 6 set2.add(new Person(3,"蓝")); 7 set2.add(new Person(4,"绿")); 8 set2.add(new Person(4,"绿")); 9 10 //迭代器遍历 11 Iterator<Person> iter=set2.iterator(); 12 while(iter.hasNext()){ 13 Person p=iter.next(); 14 System.out.println(p.getId()+" "+p.getName()); 15 } 16 17 class Person{ 18 private int id; 19 private String name; 20 21 /* 22 * 如果不重写hashCode和equals方法，存入相同数据时将无法比对 23 * 24 */ 25 @Override 26 public int hashCode() { 27 final int prime = 31; 28 int result = 1; 29 result = prime * result + id; 30 result = prime * result + ((name == null) ? 0 : name.hashCode()); 31 return result; 32 } 33 @Override 34 public boolean equals(Object obj) { 35 if (this == obj) 36 return true; 37 if (obj == null) 38 return false; 39 if (getClass() != obj.getClass()) 40 return false; 41 Person other = (Person) obj; 42 if (id != other.id) 43 return false; 44 if (name == null) { 45 if (other.name != null) 46 return false; 47 } else if (!name.equals(other.name)) 48 return false; 49 return true; 50 } 51 public Person() { 52 super(); 53 } 54 public Person(int id, String name) { 55 super(); 56 this.id = id; 57 this.name = name; 58 } 59 public int getId() { 60 return id; 61 } 62 public void setId(int id) { 63 this.id = id; 64 } 65 public String getName() { 66 return name; 67 } 68 public void setName(String name) { 69 this.name = name; 70 } 71 72 }
5. TreeSet
将存入的数据，进行排序，然后输出。
如果传入的是一个实体对象，那么需要传入比较器：实体类实现Comparable接口，并重写CompareTo方法；
1 //TreeSet从小到大输出。存入元素，默认升序排序；存入实体对象，需要传入比较器 2 Set<Person> set3=new TreeSet<Person>(); 3 set3.add(new Person(11,"a")); 4 set3.add(new Person(22,"b")); 5 set3.add(new Person(33,"c")); 6 set3.add(new Person(44,"d")); 7 8 //迭代器遍历 9 Iterator<Person> iter=set3.iterator(); 10 while(iter.hasNext()){ 11 Person p=iter.next(); 12 System.out.println(p.getId()+" "+p.getName()); 13 } 14 15 class Person implements Comparable{ //实现 16 private int id; 17 private String name; 18 19 //compareTo方法判断传入的对象和已有对象 20 @Override 21 public int compareTo(Object o) { 22 Person p=null; 23 if(o instanceof Person){ 24 p=(Person)o; 25 }else{ 26 return 0; 27 } 28 return this.id -p.getId(); //为正数，升序；为负数，降序；等于0，位置不变 29 } 30 31 public Person() { 32 super(); 33 } 34 public Person(int id, String name) { 35 super(); 36 this.id = id; 37 this.name = name; 38 } 39 public int getId() { 40 return id; 41 } 42 public void setId(int id) { 43 this.id = id; 44 } 45 public String getName() { 46 return name; 47 } 48 public void setName(String name) { 49 this.name = name; 50 } 51 52 53 }
三、Map接口
1. Map接口的特点：
以键值对的形式存储数据，以键取值。键不能重复，值可以重复。
2. Map接口的现已知常用实现类有：
HashMap、HashTable、LinkedHashMap、TreeMap
3. 常用方法：
put（key，value）：向Map的最后追加一个键值对；
get（key）：通过键，取到一个值；
clear（）：清除Map中的所有数据；
containsKey（key）：检测是否包含指定的键；
containsValue（obj）：检测是否包含指定的值；
replace（）：替换指定键的值；
4. 遍历Map
a. keySet（）：返回Set，先取键，再取值；
b. values（）：返回Collection，直接取值；
c. 取代一个entry键值对，返回Set<Entry<>>；
1 Map<String, String> map1=new HashMap<String, String>(); 2 map1.put("01", "aaaaaa"); 3 map1.put("02", "bbbbbb"); 4 map1.put("03", "cccccc"); 5 map1.put("04", "dddddd"); 6 // map1.clear(); //清除所有数据 7 System.out.println(map1.containsKey("01")); //返回true 8 System.out.println(map1.containsValue("aaaa")); //返回false 9 System.out.println(map1.replace("03", "dddddd")); //将cccccc替换为dddddd 10 System.out.println(map1.get("02")); //返回bbbbbb 11 12 /** 13 * 遍历Map的方式一，先取键，再取值 14 */ 15 Set<String> keys=map1.keySet(); //取到所有键 16 Iterator<String> iter=keys.iterator(); 17 while(iter.hasNext()){ //迭代器遍历取到每一个键 18 String key=iter.next(); 19 System.out.println(key+" "+map1.get(key)); //key:取到键 map1.get(key):取到每个键对应的值 20 } 21 22 /** 23 * 遍历Map的方式二，直接取值；只能取到值 24 */ 25 Collection<String> values = map1.values(); 26 Iterator<String> iter1= values.iterator(); 27 while(iter1.hasNext()){ 28 System.out.println(iter1.next()); 29 } 30 31 /** 32 * 遍历Map的方式三,取到一个entry键值对 33 */ 34 Set<Entry<String,String>> set= map1.entrySet(); 35 Iterator<Entry<String,String>> iter2=set.iterator(); 36 while(iter2.hasNext()){ 37 Entry<String,String> entry=iter2.next(); 38 System.out.println(entry.getKey()+" "+entry.getValue()); 39 } 40
5. LinkedHashMap
可以使用列表，记录数据放入的次序，输出的顺序与放入的顺序一致。与LinkEDHashSet一样。
6. TreeMap
根据键的顺序，进行排序后输出。与TreeSet。
如果传入的是实体对象，必须重写比较函数。
7. HashMap和HashTable的区别？
a. HashTable是线程安全的，HashMap是线程不安全的；
b. HashTable的键不能为null，HashMap的键可以为null；
c. HashTable继承自Dirctionary字典类，HashMap继承自abstract类；
d. 扩容大小：HashTable两倍，HashMap两倍加一；
e. 初始容量：HashTable为11，HashMap为16；两者的填充因子默认都是0.75；