Java集合框架

it2024-12-03 3

一、集合

1、集合的概念

集合：对象的容器，定义了对多个对象进行操作的常用方法，可实现类似数组的功能。集合和数组的区别：

2、Collection接口

（1）Collection父接口特点：代表一组任意类型的对象。

纠正：上图判断是否相等是equals()

import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; /** * Collection接口使用 * 1、添加元素 * 2、删除元素 * 3、遍历元素 * 4、判断（元素是否存在是否为空） * @author ymx */ public class demo_collection { 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);//调用toString方法 //2、删除元素 // collection.remove("香蕉"); // System.out.println("删除之后："+collection.size()); // System.out.println(collection); // //5、清空 // collection.clear(); // System.out.println("清空之后："+collection.size()); // System.out.println(collection); //3、遍历元素* //方式一增强的for循环 System.out.println("-------------1、使用增强的for循环遍历------------"); for (Object object:collection){ System.out.println(object); } //方式二迭代器: 专门用来遍历集合的一种方式 /* 迭代器 3个方法 hasNext() 是否有下一个元素还有元素吗？ next()获取下一个元素 remove（）移除元素在迭代器遍历中不能够使用Collection的修改删除方法并发修改异常（不能够使用Collection的其他方法改变集合元素） Exception in thread "main" java.util.ConcurrentModificationException */ System.out.println("-------------2、使用迭代器循环遍历------------"); Iterator it= collection.iterator(); while(it.hasNext()){ String s=(String)it.next(); System.out.println(s); //collection.remove(s);不能使用Collection的删除方法 // it.remove();//但可以使用迭代器自己的删除方法 } System.out.println("元素个数："+collection.size()); //4、判断 //4.1 判断某元素是否存在 System.out.println(collection.contains("西瓜")); //4.2判断集合是否为空 System.out.println(collection.isEmpty()); } }

import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; /** * Collection的使用 * 保存学生信息需新建学生类 */ public class Demo1_collection { public static void main(String[] args){ Collection collection=new ArrayList(); //1添加学生数据 Student s1=new Student("HELEN",20); Student s2=new Student("JANE",25); Student s3=new Student("MACTICAL",21); //加的是地址删除的是指向的指针 collection.add(s1); collection.add(s2); collection.add(s3); collection.add(s3);//List可以元素重复 System.out.println("元素个数："+collection.size()); System.out.println(collection.toString()); //2、删除 collection.remove(s3);//只删掉了第一个遇到的s3 System.out.println("删除之后的元素个数："+collection.size()); System.out.println(collection.toString()); collection.remove(s3);//删掉了原第二个s3 System.out.println("删除之后的元素个数："+collection.size()); System.out.println(collection.toString()); //3、清空 collection.clear(); System.out.println("清空之后的元素个数："+collection.size()); collection.add(s1); collection.add(s2); collection.add(s3); //4、遍历 System.out.println("-------------1、使用增强的for循环遍历------------"); for (Object object:collection){ Student s=(Student)object; System.out.println(s.toString()); } System.out.println("-------------2、使用迭代器循环遍历------------"); Iterator it=collection.iterator(); while(it.hasNext()){ Student ss=(Student)it.next(); System.out.println(ss.toString()); } //5、判断 System.out.println(collection.contains(s1)); System.out.println(collection.isEmpty()); } }

3、List接口与实现类

（1）List子接口：特点：有序、有下标、元素可以重复。

/** * List子接口的使用 * 特点：有序有下标可重复 * @author ymx */ import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.ListIterator; public class Demo1_List { 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()); System.out.println(list); //2、删除元素 // list.remove("苹果手机"); // System.out.println("删除之后的元素个数："+list.size()); // System.out.println(list.toString()); // list.remove(0); // System.out.println("删除之后的元素个数："+list.size()); // System.out.println(list.toString()); // list.clear(); // System.out.println("清空之后的元素个数："+list.size()); //3、遍历元素：增强for 迭代器 for System.out.println("-----for----------"); for(int i=0;i<list.size();i++){ System.out.println(list.get(i)); } System.out.println("-----增强for----------"); for(Object object:list){ System.out.println(object); } System.out.println("-----迭代器iterator----------"); Iterator it=list.iterator(); while(it.hasNext()){ System.out.println(it.next()); } /* 列表迭代器listIterator：允许按任意方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置与迭代器iterator区别：列表迭代器listIterator 可以向前或向后遍历可添加删除和修改 */ ListIterator lit=list.listIterator(); System.out.println("-----列表迭代器listIterator从前往后----------"); while(lit.hasNext()){ System.out.println(lit.nextIndex()+":"+lit.next()); // System.out.println(lit.next()+","+lit.nextIndex()); } System.out.println("-----列表迭代器listIterator从后往前----------"); //此时指针已经移到最后了所以才能这么用否则要先将指针挪到最后要不遍历不了 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("苹果手机")); } }

import java.util.ArrayList; import java.util.List; /** * 保存数字数据 */ public class Demo2_List { public static void main(String[] args){ List list=new ArrayList(); //集合不能保存基本数据类型这里有一个自动装箱的操作包装类Integer 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()); // list.remove(20);//报错他这里默认就调用使用下标的删除会报数组越界的错误 //Exception in thread "main" java.lang.IndexOutOfBoundsException: //下标或强制类型转换可以 // list.remove(0); //list.remove((Object)20); list.remove(new Integer(20)); System.out.println("删除之后元素个数:"+list.size()); System.out.println(list.toString()); //subList方法左包含右不包含含头不含尾 List subList=list.subList(1,3); System.out.println(subList); System.out.println(list); } }

（2）List实现类： ①ArrayList:数组列表集合，内部采用数组方式存储。数组结构实现、查询快、增删慢；运行速率快、线程不安全。 ②Vertor：数组结构实现、查询快、增删慢；运行效率慢、线程安全。 ③LinkedList：链表结构实现、增删快、查询慢；运行效率、线程不安全。 ArrayList源码分析：默认容量大小：DEFAULT_CAPACITY = 10 注：如果没有向集合中添加任何元素时容量是0；添加一个元素之后容量就是10，10个之后会扩容，每次扩容大小为原来的1.5倍。存放元素的数组：elementData 实际元素个数：size 添加元素：add

public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; } private static int calculateCapacity(Object[] elementData, int minCapacity) { if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { return Math.max(DEFAULT_CAPACITY, minCapacity); } return minCapacity; } private void ensureCapacityInternal(int minCapacity) { ensureExplicitCapacity(calculateCapacity(elementData, minCapacity)); } private void ensureExplicitCapacity(int minCapacity) { modCount++; // overflow-conscious code if (minCapacity - elementData.length > 0) grow(minCapacity); } private void grow(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; int newCapacity = oldCapacity + (oldCapacity >> 1); if (newCapacity - minCapacity < 0) newCapacity = minCapacity; if (newCapacity - MAX_ARRAY_SIZE > 0) newCapacity = hugeCapacity(minCapacity); // minCapacity is usually close to size, so this is a win: elementData = Arrays.copyOf(elementData, newCapacity); }

例子：添加、删除、查询、遍历、判断

import java.util.ArrayList; import java.util.Iterator; import java.util.ListIterator; /** * ArrayList的使用 * 存储结构：数组查询遍历快增删慢 */ public class Demo1_ArrayList { public static void main(String[] args){ ArrayList arrayList=new ArrayList(); Student s1=new Student("肖战",29); Student s2=new Student("王一博",23); Student s3=new Student("陈情令",2); arrayList.add(s1); arrayList.add(s2); arrayList.add(s3); System.out.println("元素个数："+arrayList.size()); System.out.println(arrayList.toString()); // arrayList.remove(s1); // System.out.println("元素个数："+arrayList.size()); arrayList.remove(new Student("王一博",23)); //这样删不掉内部调用Object的equals方法判断的是false ，equals（this==obj）使用地址作比较的需要重写equals方法 System.out.println("删除后的元素个数："+arrayList.size()); System.out.println(arrayList.toString()); System.out.println("-----迭代器iterator----------"); Iterator it=arrayList.iterator(); while(it.hasNext()){ Student s=(Student)it.next(); System.out.println(s.toString()); } System.out.println("-----列表迭代器listIterator从前往后----------"); ListIterator lit=arrayList.listIterator(); while(lit.hasNext()){ Student s=(Student)lit.next(); System.out.println(s.toString()); } System.out.println(arrayList.contains(new Student("肖战",29))); System.out.println(arrayList.isEmpty()); System.out.println(arrayList.indexOf(s1)); } }

Vector： Vector类实现了可扩展的对象数组。

import java.util.Enumeration; import java.util.Vector; /** * Vector集合 * 存储结构：数组 */ public class Demo_vector { public static void main(String[] args){ Vector vector=new Vector(); vector.add("草莓"); vector.add("苹果"); vector.add("西瓜"); System.out.println(vector.size()); //使用枚举器 Enumeration en =vector.elements(); while(en.hasMoreElements()){ String o=(String)en.nextElement(); System.out.println(o.toString()); } } }

LinkedList源码分析： int size：集合的大小 Node first:链表的头节点 Node last: 链表的尾节点

void linkLast(E e) { final Node<E> l = last; final Node<E> newNode = new Node<>(l, e, null); last = newNode; if (l == null) first = newNode; else l.next = newNode; size++; modCount++; } private static class Node<E> { E item; Node<E> next; Node<E> prev; Node(Node<E> prev, E element, Node<E> next) { this.item = element; this.next = next; this.prev = prev; } }

例子：添加、删除、查询、遍历、判断

import java.util.Iterator; import java.util.LinkedList; import java.util.ListIterator; /** * LinkedList的使用 * 存储结构：双向链表 */ public class Demo1_LinkedList { public static void main(String[] args){ LinkedList linkedList=new LinkedList(); Student s1=new Student("肖战",29); Student s2=new Student("王一博",23); Student s3=new Student("肖战",22); linkedList.add(s1); linkedList.add(s2); linkedList.add(s3); System.out.println(linkedList.size()); System.out.println(linkedList.toString()); linkedList.remove(s3); System.out.println(linkedList.toString()); // linkedList.clear(); for(int i=0;i<linkedList.size();i++){ System.out.println(linkedList.get(i)); } for(Object object:linkedList){ Student s=(Student)object; System.out.println(s); } Iterator it=linkedList.iterator(); while(it.hasNext()){ System.out.println(it.next()); } ListIterator lit=linkedList.listIterator(); while(lit.hasNext()){ System.out.println(lit.next()); } System.out.println(linkedList.contains(s1)); System.out.println(linkedList.isEmpty()); System.out.println(linkedList.indexOf(s1)); } }

ArrayList和LinkedList的区别：

4、泛型和工具类

（1）本质：参数化类型，把类型作为参数传递；JDK1.5引入（2）常见形式：泛型类、泛型接口、泛型方法。（3）语法： <T,…> T称为类型占位符，表示一种引用类型。（4）好处：提高代码的重用性；防止类型转换异常，提高代码的安全性。泛型类、泛型接口、泛型方法

/** * 泛型类 * 语法在类名的后边加上<T> * T 类型占位符表示一种引用类型如果编写多个使用逗号隔开 */ public class Demo1_generic<T> { //使用泛型T //1、创建变量 T t; //2、泛型作为方法的参数 public void show(T t){ //不能new一个对象不能实例化 System.out.println(t); } //3、泛型作为方法的返回值 public T getT(){ return t; } } /** * 泛型接口 * 语法接口名<T> * 不能使用泛型创建静态常量 */ public interface My_Interface<T> { //包含抽象方法和静态常量 String name="HELEN"; T server(T t); } public class MyInterfaceImpl implements My_Interface<String>{ public String server(String t){ System.out.println(t); return null; } } public class MyInterfaceImpl2<T> implements My_Interface<T> { @Override public T server(T t) { System.out.println(t); return null; } } /** * 泛型方法 * 语法：放在方法返回值的前边 * <T>返回值类型 */ public class MyGenericMethod { //泛型方法 public <T> T show(T t){ System.out.println("泛型方法"+t); return t; } } public class TestGeneric { public static void main(String[] args){ //使用泛型类 //注：泛型只能使用引用对象，不同泛型类型对象之间不能相互赋值 Demo1_generic<String> myGeneric=new Demo1_generic<>(); myGeneric.t="hello"; myGeneric.show("hello world"); String s=myGeneric.getT(); System.out.println(s); Demo1_generic<Integer> myGeneric2=new Demo1_generic<>(); myGeneric2.t=1000; myGeneric2.show(2000); System.out.println(myGeneric2.getT()); //Demo1_generic<String> myGeneric4=myGeneric2;不同泛型类型对象之间不能相互赋值会报错 //Demo1_generic<String> myGeneric4=myGeneric; 同泛型类型对象之间能相互赋值 MyInterfaceImpl impl=new MyInterfaceImpl(); impl.server("helen"); MyInterfaceImpl2<Integer> impl2=new MyInterfaceImpl2<>(); impl2.server(1234); //泛型方法 MyGenericMethod myGenericMethod=new MyGenericMethod(); myGenericMethod.show("hello world generic"); myGenericMethod.show(200); } }

（5）泛型集合概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致。特点：编译时即可检查，而非运行时抛出异常；访问时，不必类型转换（拆箱）；不同泛型之间引用不能相互赋值，泛型不存在多态。

import java.util.ArrayList; import java.util.Iterator; public class Demo3 { public static void main(String[] args){ ArrayList<String> arrayList=new ArrayList<String>(); arrayList.add("xxx"); arrayList.add("aaa"); // arrayList.add(123); // arrayList.add(234); // for(Object object:arrayList){ // //Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String // String str=(String)object; // System.out.println(str); // } for(String string:arrayList){ System.out.println(string); } ArrayList<Student> arrayList2=new ArrayList<Student>(); Student s1=new Student("肖战",29); Student s2=new Student("肖战",19); arrayList2.add(s1); arrayList2.add(s2); Iterator<Student> it=arrayList2.iterator(); while(it.hasNext()){ Student a=it.next(); System.out.println(a); } } }

5、Set接口与实现类

（1）Set接口：特点：无序、无下标、元素不可以重复。

import java.util.HashSet; import java.util.Iterator; import java.util.Set; /** * 测试Set接口的使用 * 无序（添加和遍历顺序不一致、无下标元素不能重复） */ public class Demo_set { public static void main(String[] args){ Set<String> set=new HashSet<>(); //1 添加数据 set.add("apple phone"); set.add("HUAWEI "); set.add("xiaomi"); System.out.println(set.size()); System.out.println(set.toString()); //2、删除数据 // set.remove("xiaomi"); // System.out.println(set.toString()); // set.clear(); // System.out.println(set.size()); //3、遍历 //增强for 没有下标普通循环不行 System.out.println("-------增强for--------------"); for(String string:set){ System.out.println(string); } System.out.println("-------迭代器iteritor--------------"); Iterator<String> iterator=set.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); } //4、查找判断 System.out.println(set.contains("huawei")); System.out.println(set.isEmpty()); } }

（2）Set实现类：

import javax.print.attribute.HashAttributeSet; import java.util.HashSet; import java.util.Iterator; /** * HashSet 集合的使用 * 存储结构：哈希表（数组+链表+红黑树） */ public class Demo_HashSet { public static void main(String[] args){ HashSet<String> hashSet=new HashSet<>(); hashSet.add("xiaozhan"); hashSet.add("xiaozan"); hashSet.add("me"); System.out.println(hashSet.size()); System.out.println(hashSet.toString()); hashSet.remove("me"); System.out.println(hashSet.toString()); System.out.println("-------增强for--------------"); for(String string:hashSet){ System.out.println(string); } System.out.println("-------迭代器iteritor--------------"); Iterator<String> iterator=hashSet.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); } System.out.println(hashSet.contains("me")); System.out.println(hashSet.isEmpty()); } } public class Person { private String name; private int age; public Person(){ } public Person(String name, int age) { 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() { int n1=this.name.hashCode(); int n2=this.age; return n1+n2; } @Override public boolean equals(Object obj) { if(this==obj){ return true; } if(this==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; } } import java.util.HashSet; import java.util.Iterator; /** *使用HashSet * 存储结构哈希表 * 存储过程： * （1）根据hashcode计算保存的位置，如果此位置为空，则直接保存，如果不为空指定第二步 * （2）在执行equals方法，如果equals方法结果为true 则认为重复，否则形成链表 */ public class Demo1_HashSet { public static void main(String[] args) { HashSet<Person> person=new HashSet<>(); Person p1=new Person("zhangsna",22); Person p2=new Person("zhaa",22); Person p3=new Person("zz",22); person.add(p1); person.add(p2); person.add(p3); System.out.println(person.size()); System.out.println(person.toString()); person.add(new Person("zz",22)); //重写两个方法 hashCode equals 确保名字年龄一样的不会被加进来 //如果不重写的话它们是不同的对象就会被填进来 System.out.println(person.toString()); person.remove(p3); System.out.println(person.toString()); person.remove(new Person("zhaa",22));//重写那两个方法后可以删掉 System.out.println(person.toString()); person.add(p2); person.add(p3); System.out.println("-------增强for--------------"); for(Person person1:person){ System.out.println(person1); } System.out.println("-------迭代器iteritor--------------"); Iterator<Person> iterator=person.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); } System.out.println(person.contains(p1)); System.out.println(person.contains(new Person("zhaa",22))); System.out.println(person.isEmpty()); } }

import java.util.Iterator; import java.util.TreeSet; /** * TreeSet * 存储结构红黑树 * 要求元素必须实现Comparable接口，compareTo（）方法返回值为0，认为是重复元素 */ public class Demo1_TreeSet { public static void main(String[] args) { TreeSet<Person> persons=new TreeSet<>(); //Exception in thread "main" java.lang.ClassCastException: Person cannot be cast to java.lang.Comparable Person p1=new Person("a肖战",29); Person p2=new Person("a肖",29); Person p3=new Person("b战",29); Person p4=new Person("a肖战",9); persons.add(p1); persons.add(p2); persons.add(p3); persons.add(p4); System.out.println(persons.toString()); persons.remove(p1); System.out.println(persons.toString()); persons.remove(p2); System.out.println(persons.toString()); System.out.println("-----for----"); for(Person s:persons){ System.out.println(s); } System.out.println("-----iterator----"); Iterator<Person> iterator=persons.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); } System.out.println(persons.contains(p3)); System.out.println(persons.contains(new Person("b战",29);)); System.out.println(persons.isEmpty()); } } public class Person implements Comparable<Person>{ private String name; private int age; public Person(){ } public Person(String name, int age) { 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() { int n1=this.name.hashCode(); int n2=this.age; return n1+n2; } @Override public boolean equals(Object obj) { if(this==obj){ return true; } if(this==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; } //先按姓名比较再按年龄比较 @Override public int compareTo(Person o) { int n1=this.getName().compareTo(o.getName()); int n2=this.age-o.getAge(); return n1==0?n2:n1; } }

import java.util.Comparator; import java.util.TreeSet; /** * TreeSet的使用 * Comparator: 实现定制比较、比较器 * Comparable:可比较的 */ public class Demo2_TreeSet { 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("zs",24); Person p4=new Person("abc",20); persons.add(p1); persons.add(p2); persons.add(p3); persons.add(p4); System.out.println(persons.toString()); } }

import java.util.Comparator; import java.util.TreeSet; /** * 要求：使用TreeSet集合实现字符串按长度进行排序 * Comparator 接口实现定制比较 */ public class Demo_treesetex { 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("hello world"); treeSet.add("apple"); treeSet.add("beijing"); treeSet.add("hello kitty"); treeSet.add("xian"); treeSet.add("nanjing"); treeSet.add("lisi"); System.out.println(treeSet.toString()); } }

6、Map接口与实现类

import com.sun.javafx.collections.MappingChange; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; /** *Map接口的使用 * 特点：存储的是键值对键不可重复值可重复无序 */ public class Demo1_map { public static void main(String[] args) { //1、创建 Map<String,String> map=new HashMap<>(); map.put("cn","中国"); map.put("uk","英国"); map.put("usa","美国"); System.out.println(map.size()); System.out.println(map.toString()); map.put("CN","中国"); map.put("cn","china"); System.out.println(map.size()); System.out.println(map.toString()); //2、删除 map.remove("cn"); System.out.println(map.size()); System.out.println(map.toString()); //3、遍历 //方式一使用keySet(）得到的是Set集合可以用迭代器或增强的for循环遍历 System.out.println("----------使用keySet(）增强for------------"); Set<String> keyset=map.keySet(); for(String key:keyset){ System.out.println(key+"---"+map.get(key)); } System.out.println("----------使用keySet(）迭代器------------"); Iterator<String> iterator=keyset.iterator(); while(iterator.hasNext()){ String k=iterator.next(); System.out.println(k+"---"+map.get(k)); } //方法二：使用 entrySet()方法方法二效率高于方法一 System.out.println("----------使用 entrySet()方法增强for------------"); Set<Map.Entry<String,String>> entries=map.entrySet(); for(Map.Entry<String,String> entry:entries){ System.out.println(entry.getKey()+"----"+entry.getValue()); } System.out.println("----------使用 entrySet()方法迭代器------------"); Iterator<Map.Entry<String,String>> iterator1=entries.iterator(); while (iterator1.hasNext()){ Map.Entry<String,String> k=iterator1.next(); System.out.println(k.getKey()+"-----"+k.getValue()); } //4、判断 System.out.println(map.containsKey("cn")); System.out.println(map.containsValue("中国")); System.out.println(map.isEmpty()); } } 3 {usa=美国, uk=英国, cn=中国} 4 {usa=美国, uk=英国, cn=china, CN=中国} 3 {usa=美国, uk=英国, CN=中国} ----------使用keySet(）增强for------------ usa---美国 uk---英国 CN---中国 ----------使用keySet(）迭代器------------ usa---美国 uk---英国 CN---中国 ----------使用 entrySet()方法增强for------------ usa----美国 uk----英国 CN----中国 ----------使用 entrySet()方法迭代器------------ usa-----美国 uk-----英国 CN-----中国 false true false

（1）Map的实现类 HashMap线程不安全，运行效率快；允许用null作为key或是value。 HashMap源码分析： ①HashMap刚创建时，table是null，为了节省空间，当添加第一个元素时，table容量调整为16； ②当元素个数大于阈值（16*0.75=12）时，会进行扩容，扩容后大为原来的2倍，目的是减少调整元素的个数； ③jdk1.8 当每个链表长度大于8，并且元素个数大于等于64时，会调整为红黑树，目的是提高执行效率； ④jdk1.8 当链表长度小于6时，调整为链表； ⑤jdk1.8 以前，链表时头插入，jdk1.8 之后是尾插入。

import java.util.HashMap; import java.util.Map; /** * HashMap 集合的使用 * 存储结构：哈希表数组加链表红黑树 * 使用key的hashcode和equals作为重复依据 */ public class Demo1_HashMap { public static void main(String[] args) { HashMap<Student_map,String> hashMap=new HashMap<>(); //刚创建hashmap之后没有添加元素此时table=null size=0 目的节省空间 Student_map s1=new Student_map("张三",11); Student_map s2=new Student_map("李四",12); Student_map s3=new Student_map("王舞",13); Student_map s4=new Student_map("王陆",14); hashMap.put(s1,"male"); hashMap.put(s2,"male"); hashMap.put(s3,"female"); hashMap.put(s4,"male"); hashMap.put(new Student_map("王陆",14),"male"); System.out.println(hashMap.size()); System.out.println(hashMap.toString()); hashMap.remove(s1); System.out.println("删除之后"+hashMap.size()); System.out.println(hashMap.toString()); //遍历 System.out.println("----------使用keySet(）增强for------------"); for(Student_map key:hashMap.keySet()){ System.out.println(key.toString()+"="+hashMap.get(key)); } System.out.println("----------使用 entrySet()方法增强for------------"); for(Map.Entry<Student_map,String> entry:hashMap.entrySet()){ System.out.println(entry.getKey()+"="+entry.getValue()); } //判断 System.out.println(hashMap.containsKey(s1)); System.out.println(hashMap.containsValue("male")); System.out.println(hashMap.containsKey(new Student_map("王陆",14))); System.out.println(hashMap.isEmpty()); } } 4 {Student_map{name='王陆', stuNo=14}=male, Student_map{name='王舞', stuNo=13}=female, Student_map{name='张三', stuNo=11}=male, Student_map{name='李四', stuNo=12}=male} 删除之后3 {Student_map{name='王陆', stuNo=14}=male, Student_map{name='王舞', stuNo=13}=female, Student_map{name='李四', stuNo=12}=male} ----------使用keySet(）增强for------------ Student_map{name='王陆', stuNo=14}=male Student_map{name='王舞', stuNo=13}=female Student_map{name='李四', stuNo=12}=male ----------使用 entrySet()方法增强for------------ Student_map{name='王陆', stuNo=14}=male Student_map{name='王舞', stuNo=13}=female Student_map{name='李四', stuNo=12}=male false true true false

Hashtable:线程安全，运行效率慢；不允许用null作为key或是value。目前不常用了。 Properties：是Hashtable的子类，要求key和value都是String;通常用于配置文件的读取。 TreeMap：实现了SortedMap接口（是Map的子接口），可以对key自动排序。存储结构红黑树。

import java.util.Map; import java.util.TreeMap; /** * TreeMap的使用 *存储结构：红黑树 * */ public class Demo1_TreeMap { public static void main(String[] args) { TreeMap<Student_map,String> treeMap=new TreeMap<>(); Student_map s1=new Student_map("张三",11); Student_map s2=new Student_map("李四",12); Student_map s3=new Student_map("王舞",13); Student_map s4=new Student_map("王陆",14); treeMap.put(s1,"北京"); treeMap.put(s2,"上海"); treeMap.put(s3,"广州"); treeMap.put(s4,"深圳"); treeMap.put(new Student_map("王陆",14),"南京"); System.out.println(treeMap.size()); System.out.println(treeMap.toString()); treeMap.remove(s4); System.out.println("删除之后："+treeMap.size()); System.out.println(treeMap.toString()); System.out.println("----------使用keySet(）增强for------------"); for(Student_map key:treeMap.keySet()){ System.out.println(key+"----------"+treeMap.get(key)); } System.out.println("----------使用 entrySet()方法增强for------------"); for(Map.Entry<Student_map,String> entry:treeMap.entrySet()){ System.out.println(entry.getKey()+"-----"+entry.getValue()); } System.out.println(treeMap.containsKey(s1)); System.out.println(treeMap.containsValue("北京")); System.out.println(treeMap.isEmpty()); } } 4 {Student_map{name='张三', stuNo=11}=北京, Student_map{name='李四', stuNo=12}=上海, Student_map{name='王舞', stuNo=13}=广州, Student_map{name='王陆', stuNo=14}=南京} 删除之后：3 {Student_map{name='张三', stuNo=11}=北京, Student_map{name='李四', stuNo=12}=上海, Student_map{name='王舞', stuNo=13}=广州} ----------使用keySet(）增强for------------ Student_map{name='张三', stuNo=11}----------北京 Student_map{name='李四', stuNo=12}----------上海 Student_map{name='王舞', stuNo=13}----------广州 ----------使用 entrySet()方法增强for------------ Student_map{name='张三', stuNo=11}-----北京 Student_map{name='李四', stuNo=12}-----上海 Student_map{name='王舞', stuNo=13}-----广州 true true false

7、Collections工具类

Collections工具类：集合工具类，定义了除了存取以外的集合常用方法。

import java.lang.reflect.Array; import java.util.*; public class Demo2_Collections { 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复制 //Exception in thread "main" java.lang.IndexOutOfBoundsException: Source does not fit in dest //要求两个集合大小得相同元素个数得一样才能复制 List<Integer> list1=new ArrayList<>(); for(int j=0;j<list.size();j++){ list1.add(0); } Collections.copy(list1,list); System.out.println(list1.toString()); //reverse反转 Collections.reverse(list); System.out.println("反转之后："+list.toString()); //shuffle打乱元素顺序 Collections.shuffle(list); System.out.println("打乱之后："+list.toString()); //list转成数组 System.out.println("list转化为数组"); Integer[] arr=list.toArray(new Integer[0]); System.out.println(arr.length); System.out.println(Arrays.toString(arr)); System.out.println(arr[1]); //数组转成list 这个集合是个受限集合不能添加和删除元素 System.out.println("数组转化为list"); String[] names={"王舞","王陆","张三"}; List<String> list2=Arrays.asList(names); //list2.add("zhang");//不能添加和删除元素报错Exception in thread "main" java.lang.UnsupportedOperationException System.out.println(list2); //把基本类型数组转成集合需要修改为包装类才行 Integer[] nums={100,200,300,400,500}; List<Integer> list3=Arrays.asList(nums); System.out.println(list3); } }

最新回复(0)