12、集合
1、Collection体系集合
1.1、什么是集合
概念:
对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能。
和数组区别:
数组长度固定，集合长度不固定
数组可以存储基本类型和引用类型，集合只能存储引用类型
位置: java.util.*;
1.2、Collection体系集合
1.3、Collection父接口
特点:代表一组任意类型的对象，无序、无下标、不能重复
方法:
boolean add(Object obj)//添加一个对象。
boolean addAll(Collection c)//将一个集合中的所有对象添加到此集合中。
void clear()//清空此集合中的所有对象。
boolean contains(Object o)//检查此集合中是否包含o对象
boolean equals(Object o)//比较此集合是否与指定对象相等。
boolean isEmpty()//判断此集合是否为空
boolean remove(Object o)//在此集合中移除o对象.
int size()//返回此集合中的元素个数。
Object[] toArray()//将此集合转换成数组。
/** * Collection接口的使用 * (1)添加元素 * (2)删除元素 * (3)遍历元素 * (4)判断 * */ public class Demo1 { public static void main(String[] args) { //创建集合 Collection collection=new ArrayList(); // * (1)添加元素 collection.add("苹果"); collection.add("西瓜"); collection.add("榴莲"); System.out.println("元素个数:"+collection.size()); System.out.println(collection); // * (2)删除元素 // collection.remove("榴莲"); // collection.clear(); // System.out.println("删除之后:"+collection.size()); // * (3)遍历元素【重点】 //3.1使用增强for System.out.println("------3.1使用增强for-------"); for (Object object : collection) { System.out.println(object); } //3.2使用迭代器(迭代器专门用来遍历集合的一种方式) //hasNext();有没有下一个元素， //next();获取下一个元素 //remove();删除当前元素 System.out.println("------3.2使用增强for-------"); Iterator it=collection.iterator(); while(it.hasNext()) { String s=(String)it.next(); System.out.println(s); //不能使用collection删除方法 //collection.remove(s); // 可以使用it.remove删除方法 //it.remove(); } System.out.println("元素个数:"+collection.size()); // * (4)判断 System.out.println(collection.contains("西瓜")); System.out.println(collection.isEmpty()); } }
/** * 学生类 * */ public class Student { private String name; private int age; public Student() { } public Student(String name, int age) { super(); this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Student [name=" + name + ", age=" + age + "]"; } @Override public boolean equals(Object obj) { //1判断是不是同一个对象 if(this==obj) { return true; } //2判断是否为空 if(obj==null) { return false; } //3判断是否是Student类型 if(obj instanceof Student) { Student s=(Student)obj; //4比较属性 if(this.name.equals(s.getName())&&this.age==s.getAge()) { return true; } } //5不满足条件返回false return false; } }
/** * Collection的使用:保存学生信息 * */ public class Demo2 { public static void main(String[] args) { //新建Collection对象 Collection collection=new ArrayList(); Student s1=new Student("张三", 20); Student s2=new Student("张无忌", 18); Student s3=new Student("王二", 22); //1添加数据 collection.add(s1); collection.add(s2); collection.add(s3); System.out.println("元素个数:"+collection.size()); System.out.println(collection.toString()); //2删除 // collection.remove(s1); // collection.remove(new Student("王二", 22)); // collection.clear(); // System.out.println("删除之后:"+collection.size()); //3遍历 //3.1 增强for System.out.println("-------增强for----"); for (Object object : collection) { Student s=(Student)object; System.out.println(s.toString()); } //3.2迭代器: hasNext() next(); remove(); 迭代过程中不能使用使用collection的删除方法 System.out.println("-------迭代器----"); Iterator it=collection.iterator(); while(it.hasNext()) { Student s=(Student)it.next(); System.out.println(s.toString()); } //4判断 System.out.println(collection.contains(s1)); System.out.println(collection.isEmpty()); } }
2、List集合
2.1、List子接口
特点:
有序、有下标、元素可以重复。
方法:
void add(int index, Object o) //在index位置插入对象o。
boolean addAll(int index, Collection c) //将一个集合中的元素添加到此集合中的index位置。
Object get(int index) //返回集合中指定位置的元素。
List subList(int fromIndex, int tolndex) //返回fromIndex和tolndex之间的集合元素。
/** * List子接口的使用 * 特点：1 有序 有下标 2 可以重复 * */ public class Demo3 { public static void main(String[] args) { //先创建集合对象 List list=new ArrayList<>(); //1添加元素 list.add("苹果"); list.add("小米"); list.add(0, "华为"); System.out.println("元素个数:"+list.size()); System.out.println(list.toString()); //2删除元素 //list.remove("苹果"); // list.remove(0); // System.out.println("删除之后:"+list.size()); // System.out.println(list.toString()); //3遍历 //3.1使用for遍历 System.out.println("-----3.1使用for遍历-----"); for(int i=0;i<list.size();i++) { System.out.println(list.get(i)); } //3.2使用增强for System.out.println("-----3.2使用增强for-----"); for (Object object : list) { System.out.println(object); } //3.3使用迭代器 Iterator it=list.iterator(); System.out.println("-----3.3使用迭代器-----"); while(it.hasNext()) { System.out.println(it.next()); } //3.4使用列表迭代器 ,和Iterator的区别，ListIterator可以向前或向后遍历，添加、删除、修改元素 ListIterator lit=list.listIterator(); System.out.println("------3.4使用列表迭代器从前往后-------"); while(lit.hasNext()) { System.out.println(lit.nextIndex()+":"+lit.next()); } System.out.println("------3.4使用列表迭代器后往前-------"); while(lit.hasPrevious()) { System.out.println(lit.previousIndex()+":"+lit.previous()); } //4判断 System.out.println(list.contains("苹果")); System.out.println(list.isEmpty()); //5获取位置 System.out.println(list.indexOf("华为")); } }
/** * List的使用 * @author wgy * */ public class Demo4 { public static void main(String[] args) { //创建集合 List list=new ArrayList(); //1添加数字数据(自动装箱) list.add(20); list.add(30); list.add(40); list.add(50); list.add(60); System.out.println("元素个数:"+list.size()); System.out.println(list.toString()); //2删除操作 //list.remove(0); // list.remove(new Integer(20)); // System.out.println("删除元素:"+list.size()); // System.out.println(list.toString()); //3补充方法subList：返回子集合,含头不含尾 List subList=list.subList(1, 3); System.out.println(subList.toString()); } }
2.2、List实现类
ArrayList【重点】:
数组结构实现，查询快、增删慢;
JDK1.2版本，运行效率快、线程不安全。
Vector:
数组结构实现，查询快、增删慢;.
JDK1.0版本，运行效率慢、线程安全。
LinkedList:
链表结构实现，增删快，查询慢。
/** * ArrayList的使用 * 存储结构:数组，查找遍历速度块，增删慢 * @author wgy * */ public class Demo5 { public static void main(String[] args) { //创建集合 size 0 容量 0，扩容原来的1.5倍 ArrayList arrayList=new ArrayList<>(); //1添加元素 Student s1=new Student("刘德华", 20); Student s2=new Student("郭富城", 22); Student s3=new Student("梁朝伟", 18); arrayList.add(s1); arrayList.add(s2); arrayList.add(s3); System.out.println("元素个数:"+arrayList.size()); System.out.println(arrayList.toString()); //2删除元素 // arrayList.remove(new Student("刘德华", 20));//equals(this==obj) // System.out.println("删除之后:"+arrayList.size()); //3遍历元素【重点】 //3.1使用迭代器 System.out.println("-------3.1使用迭代器-----"); Iterator it=arrayList.iterator(); while(it.hasNext()) { Student s=(Student)it.next(); System.out.println(s.toString()); } //3.2列表迭代器 ListIterator lit=arrayList.listIterator(); System.out.println("-------3.2使用列表迭代器---------"); while(lit.hasNext()) { Student s=(Student)lit.next(); System.out.println(s.toString()); } System.out.println("-------3.2使用列表迭代器逆序---------"); while(lit.hasPrevious()) { Student s=(Student)lit.previous(); System.out.println(s.toString()); } //4判断 System.out.println(arrayList.contains(new Student("梁朝伟", 18))); System.out.println(arrayList.isEmpty()); //5查找 System.out.println(arrayList.indexOf(new Student("梁朝伟", 18))); } }
/** * 演示Vector集合的使用 * 存储结构:数组 * */ public class Demo1 { public static void main(String[] args) { //创建集合 Vector vector=new Vector<>(); //1添加元素 vector.add("草莓"); vector.add("芒果"); vector.add("西瓜"); System.out.println("元素个数:"+vector.size()); //2删除 // vector.remove(0); // vector.remove("西瓜"); // vector.clear(); //3遍历 //使用枚举器 Enumeration en=vector.elements(); while(en.hasMoreElements()) { String o=(String)en.nextElement(); System.out.println(o); } //4判断 System.out.println(vector.contains("西瓜")); System.out.println(vector.isEmpty()); //5vector其他方法 //firsetElement、lastElement、elementAt(); } }
/** * LinkedList的使用 * 存储结构:双向链表 * @author wgy * */ public class Demo2 { public static void main(String[] args) { //创建集合 LinkedList linkedList=new LinkedList(); //1添加元素 Student s1=new Student("刘德华", 20); Student s2=new Student("郭富城", 22); Student s3=new Student("梁朝伟", 18); linkedList.add(s1); linkedList.add(s2); linkedList.add(s3); System.out.println("元素个数:"+linkedList.size()); System.out.println(linkedList.toString()); //2删除 // linkedList.remove(new Student("刘德华", 20)); // System.out.println("删除之后:"+linkedList.size()); // linkedList.clear(); //3遍历 //3.1for遍历 System.out.println("-----for----------"); for(int i=0;i<linkedList.size();i++) { System.out.println(linkedList.get(i)); } //3.2增强for System.out.println("-----增强for----------"); for (Object object : linkedList) { Student s=(Student)object; System.out.println(s.toString()); } //3.3使用迭代器 System.out.println("-----使用迭代器----------"); Iterator it=linkedList.iterator(); while(it.hasNext()) { Student s=(Student)it.next(); System.out.println(s.toString()); } //3.4-使用列表迭代器 System.out.println("-----使用列表迭代器----------"); ListIterator lit=linkedList.listIterator(); while(lit.hasNext()) { Student s=(Student)lit.next(); System.out.println(s.toString()); } //4判断 System.out.println(linkedList.contains(s1)); System.out.println(linkedList.isEmpty()); //5获取 System.out.println(linkedList.indexOf(s2)); } }
2.3、不同结构实现方式
3、泛型
Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。
常见形式有泛型类、泛型接口、泛型方法。
语法:
<T,...>T称为类型占位符，表示一种引用类型。
好处:
提高代码的重用性
防止类型转换异常，提高代码的安全性
3.1、泛型类
/** * 泛型类 * 语法：类名<T> * T是类型占位符,表示一种引用类型,如果编写多个使用逗号隔开 * */ public class MyGeneric<T> { //使用泛型T //1创建变量 T t; //2泛型作为方法的参数 public void show(T t) { System.out.println(t); } //3泛型作为方法的返回值 public T getT() { return t; } }
3.2、泛型方法
/** * 泛型方法 * 语法：<T> 返回值类型 * */ public class MyGenericMethod { //泛型方法 public <T> T show(T t) { System.out.println("泛型方法"+t); return t; } }
3.3、泛型接口
/** * 泛型接口 * 语法：接口名<T> * 注意：不能泛型静态常量 * */ public interface MyInterface<T> { String name="张三"; T server(T t); }
public class MyInterfaceImpl implements MyInterface<String> { @Override public String server(String t) { System.out.println(t); return t; } }
public class MyInterfaceImpl2<T> implements MyInterface<T>{ @Override public T server(T t) { System.out.println(t); return t; } }
3.4、测试
public class TestGeneric { public static void main(String[] args) { //使用泛型类创建对象 //注意： // 1泛型只能使用引用类型 // 2不同泛型类型对象之间不能相互赋值 MyGeneric<String> myGeneric=new MyGeneric<String>(); myGeneric.t="hello"; myGeneric.show("大家好,加油"); String string=myGeneric.getT(); MyGeneric<Integer> myGeneric2=new MyGeneric<Integer>(); myGeneric2.t=100; myGeneric2.show(200); Integer integer=myGeneric2.getT(); //泛型接口 MyInterfaceImpl impl=new MyInterfaceImpl(); impl.server("xxxxxxx"); MyInterfaceImpl2<Integer> impl2=new MyInterfaceImpl2<>(); impl2.server(1000); //泛型方法 MyGenericMethod myGenericMethod=new MyGenericMethod(); myGenericMethod.show("中国加油"); myGenericMethod.show(200); myGenericMethod.show(3.14); } }
3.5、泛型集合
概念:
参数化类型、类型安全的集合，强制集合元素的类型必须一致。
特点:
编译时即可检查，而非运行时抛出异常。
访问时，不必类型转换(拆箱)。
不同泛型之间引用不能相互赋值,泛型不存在多态。
public class Demo3 { public static void main(String[] args) { ArrayList<String> arrayList=new ArrayList<String>(); arrayList.add("xxx"); arrayList.add("yyy"); // arrayList.add(10); // arrayList.add(20); for (String string : arrayList) { System.out.println(string); } ArrayList<Student> arrayList2=new ArrayList<Student>(); Student s1=new Student("刘德华", 20); Student s2=new Student("郭富城", 22); Student s3=new Student("梁朝伟", 18); arrayList2.add(s1); arrayList2.add(s2); arrayList2.add(s3); Iterator<Student> it=arrayList2.iterator(); while(it.hasNext()) { Student s=it.next(); System.out.println(s.toString()); } // arrayList = arrayList2; } }
4、Set集合
特点:
无序、无下标、元素不可重复。
方法:
全部继承自Collection中的方法。
使用foreach循环遍历:
for(数据类型 局部变量 : 集合名){
//循环内部的局部变量，代表当次循环从集合中取出的对象
}
/** * 测试Set接口的使用 * 特点：（1）无序、没有下标 （2）不能重复 * @author wgy * */ public class Demo1 { public static void main(String[] args) { //创建集合 Set<String> set=new HashSet<>(); //1添加数据 set.add("小米"); set.add("苹果"); set.add("华为"); //set.add("华为"); System.out.println("数据个数:"+set.size()); System.out.println(set.toString()); //2删除数据 // set.remove("小米"); // System.out.println(set.toString()); //3遍历 【重点】 //3.1使用增强for System.out.println("-----增强for-------"); for (String string : set) { System.out.println(string); } //3.2使用迭代器 System.out.println("-----使用迭代器------"); Iterator<String> it=set.iterator(); while(it.hasNext()) { System.out.println(it.next()); } //4判断 System.out.println(set.contains("华为")); System.out.println(set.isEmpty()); } }
4.1、Set实现类
HashSet【重点】:
基于HashCode实现元素不重复。
当存入元素的哈希码相同时，会调用==或equals进行确认，结果为true，拒绝后者存入。
LinkedHashSet:
链表实现的HashSet，按照链表进行存储，即可保留元素的插入顺序。
TreeSet:
基于排列顺序实现元素不重复。
实现了SortedSet接口，对集合元素自动排序。
元素对象的类型必须实现Comparable接口，指定排序规则。
通过CompareTo方法确定是否为重复元素。
4.2、HashSet
/** * HashSet集合的使用 * 存储结构:哈希表(数组+链表+红黑树) */ public class Demo2 { public static void main(String[] args) { //新建集合 HashSet<String> hashSet=new HashSet<String>(); //1添加元素 hashSet.add("刘德华"); hashSet.add("梁朝伟"); hashSet.add("林志玲"); hashSet.add("周润发"); //hashSet.add("刘德华"); System.out.println("元素个数:"+hashSet.size()); System.out.println(hashSet.toString()); //2删除数据 // hashSet.remove("刘德华"); // System.out.println("删除之后:"+hashSet.size()); //3遍历操作 //3.1增强for System.out.println("--------3.1增强for--------"); for (String string : hashSet) { System.out.println(string); } //3.2使用迭代器 System.out.println("-------3.2迭代器--------"); Iterator<String> it=hashSet.iterator(); while(it.hasNext()) { System.out.println(it.next()); } //4判断 System.out.println(hashSet.contains("郭富城")); System.out.println(hashSet.isEmpty()); } }
/** * HashSet的使用 * 存储结构:哈希表(数组+链表+红黑树) * 存储过程(重复依据) * (1)根据hashcode计算保存的位置，如果此位置为空，则直接保存，如果不为空执行第二步。 * (2)再执行equals方法，如果equals方法为true，则认为是重复，否则，形成链表 * */ public class Demo3 { public static void main(String[] args) { //创建集合 HashSet<Person> persons=new HashSet<>(); //1添加数据 Person p1=new Person("刘德华", 20); Person p2=new Person("林志玲", 22); Person p3=new Person("梁朝伟", 25); persons.add(p1); persons.add(p2); persons.add(p3); //persons.add(p3);重复 persons.add(new Person("梁朝伟", 25)); System.out.println("元素个数:"+persons.size()); System.out.println(persons.toString()); //2删除操作 //persons.remove(p1); // persons.remove(new Person("刘德华", 20)); // System.out.println("删除之后:"+persons.size()); //3遍历[重点] //3.1使用增强for for (Person person : persons) { System.out.println(person.toString()); } System.out.println("--------------"); //3.2迭代器 Iterator<Person> it=persons.iterator(); while(it.hasNext()) { System.out.println(it.next()); } //4判断 System.out.println(persons.contains(new Person("刘德华", 20))); System.out.println(persons.isEmpty()); } }
4.3、TreeSet
/** * TreeSet的使用 * 存储结构:红黑树 * */ public class Demo4 { public static void main(String[] args) { //创建集合 TreeSet<String> treeSet=new TreeSet<>(); //1添加元素 treeSet.add("xyz"); treeSet.add("abc"); treeSet.add("hello"); treeSet.add("xyz"); System.out.println("元素个数:"+treeSet.size()); System.out.println(treeSet.toString()); //2删除 // treeSet.remove("xyz"); // System.out.println("删除之后:"+treeSet.size()); //3遍历 //3.1使用增强for for (String string : treeSet) { System.out.println(string); } System.out.println("-----------"); //3.2使用迭代器 Iterator<String> it=treeSet.iterator(); while(it.hasNext()) { System.out.println(it.next()); } //4判断 System.out.println(treeSet.contains("abc")); } }
1、方式一
Person
/** * 人类 * @author wgy * */ public class Person implements Comparable<Person>{ private String name; private int age; public Person() { // TODO Auto-generated constructor stub } public Person(String name, int age) { super(); this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "Person [name=" + name + ", age=" + age + "]"; } @Override public int hashCode() { //(1)31是一个质数，减少散列冲突 (2)31提高执行效率 31*i=(i<<5)-i final int prime = 31; int result = 1; result = prime * result + age; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Person other = (Person) obj; if (age != other.age) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } //先按姓名比，然后再按年龄比 @Override public int compareTo(Person o) { int n1=this.getName().compareTo(o.getName()); int n2=this.age-o.getAge(); return n1==0?n2:n1; } // @Override // public int hashCode() { // int n1=this.name.hashCode(); // int n2=this.age; // // return n1+n2; // // } // // @Override // public boolean equals(Object obj) { // if(this==obj) { // return true; // } // if(obj==null) { // return false; // } // if(obj instanceof Person) { // Person p=(Person)obj; // // if(this.name.equals(p.getName())&&this.age==p.getAge()) { // return true; // } // } // // return false; // } }
/** * 使用TreeSet保存数据 * 存储结构:红黑树 * 要求：元素必须要实现Comparable接口,compareTo()方法返回值为0,认为是重复元素 * @author wgy * */ public class Demo5 { public static void main(String[] args) { //创建集合 TreeSet<Person> persons=new TreeSet<>(); //1添加元素 Person p1=new Person("xyz", 20); Person p2=new Person("hello", 22); Person p3=new Person("zhangsan", 25); Person p4=new Person("zhangsan", 20); persons.add(p1); persons.add(p2); persons.add(p3); persons.add(p4); System.out.println("元素个数:"+persons.size()); System.out.println(persons.toString()); //2删除 // persons.remove(p1); // System.out.println(persons.size()); //3遍历 //3.1 使用增强for for (Person person : persons) { System.out.println(person.toString()); } System.out.println("------------"); //3.2使用迭代器 Iterator<Person> it=persons.iterator(); while(it.hasNext()) { System.out.println(it.next()); } //4判断 System.out.println(persons.contains(new Person("zhangsan", 20))); } }
2、方式二
/** * TreeSet集合的使用 * Comparator:实现定制比较(比较器) * Comparable：可比较的 * @author wgy * */ public class Demo6 { public static void main(String[] args) { //创建集合,并指定比较规则 TreeSet<Person> persons=new TreeSet<>(new Comparator<Person>() { @Override public int compare(Person o1, Person o2) { int n1=o1.getAge()-o2.getAge(); int n2=o1.getName().compareTo(o2.getName()); return n1==0?n2:n1; } }); Person p1=new Person("xyz", 20); Person p2=new Person("hello", 22); Person p3=new Person("zhangsan", 25); Person p4=new Person("lisi", 25); persons.add(p1); persons.add(p2); persons.add(p3); persons.add(p4); System.out.println(persons.toString()); } }
3、练习
/** * 要求：使用TreeSet集合实现字符串按照长度进行排序 * helloworld zhang lisi wangwu beijing xian nanjing * Comparator接口实现定制比较 * */ public class Demo7 { public static void main(String[] args) { //创建集合，并指定比较规则 TreeSet<String> treeSet=new TreeSet<>(new Comparator<String>() { @Override public int compare(String o1, String o2) { int n1=o1.length()-o2.length(); int n2=o1.compareTo(o2); return n1==0?n2:n1; } }); //添加数据 treeSet.add("helloworld"); treeSet.add("pingguo"); treeSet.add("lisi"); treeSet.add("zhangsan"); treeSet.add("beijing"); treeSet.add("cat"); treeSet.add("nanjing"); treeSet.add("xian"); System.out.println(treeSet.toString()); } }
5、Map结构
5.1、Map父接口
特点:
存储一对数据(Key-Value)，无序、无下标，键不可重复，值可重复。
方法:
V put(K key，V value) //将对象存入到集合中，关联键值。key重复则覆盖原值。
Object get(Object key) //根据键获取对应的值。
Set<K> keySet()//返回所有key。
Collection<V> values()//返回包含所有值的Collection集合。
Set<Map.Entry<K，V>> entrySet() //键值匹配的Set集合。
/** * Map接口的使用 * 特点:(1)存储键值对 (2)键不能重复，值可以重复 (3)无序 * */ public class Demo1 { public static void main(String[] args) { //创建Map集合 Map<String, String> map=new HashMap<>(); //1添加元素 map.put("cn", "中国"); map.put("uk", "英国"); map.put("usa", "美国"); map.put("cn", "zhongguo"); System.out.println("元素个数:"+map.size()); System.out.println(map.toString()); //2删除 // map.remove("usa"); // System.out.println("删除之后:"+map.size()); //3遍历 //3.1使用keySet(); System.out.println("------keySet()--------"); //Set<String> keyset=map.keySet(); for (String key : map.keySet()) { System.out.println(key+"-----"+map.get(key)); } //3.2使用entrySet()方法 System.out.println("------entrySet()-----"); //Set<Map.Entry<String, String>> entries=map.entrySet(); for (Map.Entry<String, String> entry : map.entrySet()) { System.out.println(entry.getKey()+"---------"+entry.getValue()); } //4判断 System.out.println(map.containsKey("cn")); System.out.println(map.containsValue("泰国")); } }
5.2、Map集合的实现类
HashMap【重点】:
JDK1.2版本，线程不安全，运行效率快;允许用null 作为key或是value。
Hashtable :
JDK1.0版本，线程安全，运行效率慢;不允许null作为key或是value。
Properties :
Hashtable的子类，要求key和value都是String。通常用于配置文件的读取。
TreeMap :
实现了SortedMap接口(Map的子接口)，可以对key自动排序，Key需实现Comparable接口。
5.3、HashMap
1、Student
public class Student implements Comparable<Student>{ private String name; private int stuNo; public Student() { } public Student(String name, int stuNo) { super(); this.name = name; this.stuNo = stuNo; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getStuNo() { return stuNo; } public void setStuNo(int stuNo) { this.stuNo = stuNo; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((name == null) ? 0 : name.hashCode()); result = prime * result + stuNo; return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Student other = (Student) obj; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; if (stuNo != other.stuNo) return false; return true; } @Override public String toString() { return "Student [name=" + name + ", stuNo=" + stuNo + "]"; } @Override public int compareTo(Student o) { int n2=this.stuNo-o.getStuNo(); return n2; } }
2、HashMap
/** * HashMap集合的使用 * 存储结构:哈希表(数组+链表+红黑树) * 使用key的hashcode和equals作为重复 * */ public class Demo2 { public static void main(String[] args) { //创建集合 HashMap<Student, String> students=new HashMap<Student,String>(); //刚创建hashmap之后没有添加元素 table=null size=0 目的节省空间 //1添加元素 Student s1=new Student("孙悟空", 100); Student s2=new Student("猪八戒", 101); Student s3=new Student("沙和尚", 102); students.put(s1, "北京"); students.put(s2, "上海"); students.put(s3, "杭州"); //students.put(s3, "南京"); students.put(new Student("沙和尚", 102), "杭州"); System.out.println("元素个数:"+students.size()); System.out.println(students.toString()); //2删除 // students.remove(s1); // System.out.println("删除之后"+students.size()); //3遍历 System.out.println("--------keySet---------"); //3.1使用keySet(); for (Student key : students.keySet()) { System.out.println(key.toString()+"========="+students.get(key)); } System.out.println("--------entrySet---------"); //3.2使用entrySet(); for (Map.Entry<Student, String> entry : students.entrySet()) { System.out.println(entry.getKey()+"---------"+entry.getValue()); } //4判断 System.out.println(students.containsKey(new Student("孙悟空", 100))); System.out.println(students.containsValue("杭州")); } }
3、TreeMap
/** * TreeMap的使用 * 存储结构：红黑树 */ public class Demo3 { public static void main(String[] args) { //新建集合(定制比较) TreeMap<Student, String> treeMap=new TreeMap<Student,String>(); //1添加元素 Student s1=new Student("孙悟空", 100); Student s2=new Student("猪八戒", 101); Student s3=new Student("沙和尚", 102); treeMap.put(s1, "北京"); treeMap.put(s2, "上海"); treeMap.put(s3, "深圳"); treeMap.put(new Student("沙和尚", 102), "南京"); System.out.println("元素个数:"+treeMap.size()); System.out.println(treeMap.toString()); //2删除 // treeMap.remove(new Student("猪八戒", 101)); // System.out.println(treeMap.size()); //3遍历 //3.1使用keySet System.out.println("-----keySet()-------"); for (Student key : treeMap.keySet()) { System.out.println(key+"-------"+treeMap.get(key)); } System.out.println("------entrySet()--------"); for(Map.Entry<Student, String> entry : treeMap.entrySet()) { System.out.println(entry.getKey()+"--------"+entry.getValue()); } //4判断 System.out.println(treeMap.containsKey(new Student("沙和尚", 102))); } }
6、Colletions工具类
概念:
集合工具类，定义了除了存取以外的集合常用方法。
方法:
public static void reverse(List<?> list)//反转集合中元素的顺序
public static void shuffle(List<?> list)//随机重置集合元素的顺序
public static void sort(List<T> list)//升序排序（元素类型必须实现Comparable接口)
/** * 演示Collections工具类的使用 * */ public class Demo4 { public static void main(String[] args) { List<Integer> list=new ArrayList<>(); list.add(20); list.add(5); list.add(12); list.add(30); list.add(6); //sort排序 System.out.println("排序之前:"+list.toString()); Collections.sort(list); System.out.println("排序之后:"+list.toString()); //binarySearch二分查找 int i=Collections.binarySearch(list, 13); System.out.println(i); //copy复制 List<Integer> dest=new ArrayList<>(); for(int k=0;k<list.size();k++) { dest.add(0); } Collections.copy(dest, list); System.out.println(dest.toString()); //reverse反转 Collections.reverse(list); System.out.println("反转之后:"+list); //shuffle 打乱 Collections.shuffle(list); System.out.println("打乱之后:"+list); //补充： list转成数组 System.out.println("-------list转成数组 -----"); Integer[] arr=list.toArray(new Integer[10]); System.out.println(arr.length); System.out.println(Arrays.toString(arr)); //数组转成集合 System.out.println("-------数组转成集合 -----"); String[] names= {"张三","李四","王五"}; //集合是一个受限集合，不能添加和删除 List<String> list2=Arrays.asList(names); //list2.add("赵六"); //list2.remove(0); System.out.println(list2); //把基本类型数组转成集合时，需要修改为包装类型 Integer[] nums= {100,200,300,400,500}; List<Integer> list3=Arrays.asList(nums); System.out.println(list3); } }
7、总结
集合的概念:
对象的容器，和数组类似，定义了对多个对象进行操作的常用方法。
List集合:
有序、有下标、元素可以重复。（ArrayList、LinkedList、Vector)
Set集合:
无序、无下标、元素不可重复。（HashSet、TreeSet)
Map集合:
存储一对数据，无序、无下标，键不可重复，值可重复。（HashMap、HashTable、TreeMap)
Collections:
集合工具类，定义了除了存取以外的集合常用方法。
浙公网安备 33010602011771号