Java教程

Java集合框架

本文主要是介绍Java集合框架，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

目录

集合的概念

Collection接口

1.Collection父接口

2.使用迭代器遍历集合

List接口与实现类

1.列表迭代器

2.List接口实现类

泛型和工具类

⚠️注意

1.泛型类

2.泛型接口

3.泛型方法

4.泛型集合

Set接口与实现类

1.Hashset

2.TreeSet

3.Comparator接口

Map接口与实现类

1.Map父接口

2.HashMap

3.TreeMap

4.Collections工具类

集合的概念

对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能。

和数组的区别：

  1. 数组长度固定，集合长度不固定

  2. 数组可以存储基本类型和引用类型，集合只能存储引用类型。

Collection接口

1.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()：将此集合转换成数组

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
​
public class Demo01 {
   //Collection接口的使用
   //1.添加元素
   //2.删除元素
   //3.遍历元素
   //4.判断
   public static void main(String[] args) {
       //创建集合
       Collection conllection=new ArrayList();
       //添加元素
       conllection.add("apple");
       conllection.add("orange");
       conllection.add("banana");
       System.out.println("元素个数"+conllection.size());
       System.out.println(conllection);
       //删除元素
       conllection.remove("apple");
       System.out.println(conllection);
       //遍历元素[重点]
       //使用增强for遍历集合（增强for不需要下标）
       for(Object obj:conllection){
           System.out.println(obj);
      }
​
       //使用迭代器（专门用来迭代集合或遍历集合的方法）
       Iterator it=conllection.iterator();
       while(it.hasNext()){
           String object=(String)it.next();
           System.out.println(object);
           //不能使用collection删除方法，会报并发错误
           //it.remove();
      }
       System.out.println(conllection.size());
​
       //判断
       System.out.println(conllection.contains("apple"));
       System.out.println(conllection.isEmpty());
  }
}
​
/*
输出结果：
     元素个数3
     [apple, orange, banana]
     [orange, banana]
     orange
     banana
     orange
     banana
     2
     false
     false
*/

2.使用迭代器遍历集合

Iterator有三个方法用于遍历集合

  1. hasNext()：判断有没有下一个元素

  2. next()：获取下一个元素

  3. remove()：删除当前元素

import javax.swing.*;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
​
public class Demo02 {
   public static void main(String[] args) {
       //新建一个Collection对象
       Collection collection=new ArrayList();
       Student stu1=new Student("tom",21);
       Student stu2=new Student("jerry",17);
       Student stu3=new Student("young",20);
       //1添加学生数据
       collection.add(stu1);
       collection.add(stu2);
       collection.add(stu3);
       collection.add(stu3);
       System.out.println(collection.toString());
       //2删除
       collection.remove(stu2);
       System.out.println(collection.toString());
       //3遍历
       //1增强for
       for(Object obj:collection){
           Student s=(Student)obj;
           System.out.println(s.toString());
      }
       //2迭代器
       Iterator it=collection.iterator();
       while(it.hasNext()){
           Student s2=(Student)it.next();
           System.out.println(s2.toString());
      }
  }
}
​
/*
输出结果：
     [Student[name=tom,age=21], Student[name=jerry,age=17], Student[name=young,age=20], Student[name=young,age=20]]
     [Student[name=tom,age=21], Student[name=young,age=20], Student[name=young,age=20]]
     Student[name=tom,age=21]
     Student[name=young,age=20]
     Student[name=young,age=20]
     Student[name=tom,age=21]
     Student[name=young,age=20]
     Student[name=young,age=20]
*/

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 tIndex)：返回fromIndex和toIndex之间的元素。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
​
public class Demo03 {
   //List自接口的使用
   public static void main(String[] args) {
       List list=new ArrayList<>();
       //1.添加集合元素
       list.add("apple");
       list.add("huawei");
       list.add("oppo");
       list.add("oppo");
       list.add("oppo");
       System.out.println(list.size());
       System.out.println(list.toString());
       //2.删除
       list.remove("oppo");
       list.remove(1);
       System.out.println(list.toString());
       //3.遍历【重点】
       //3.1for遍历
       for(int i=0;i<list.size();i++){
           System.out.println(list.get(i));
      }
       //3.2增强for
       for(Object obj:list){
           System.out.println(obj);
      }
       //3.3迭代器
       Iterator it=list.iterator();
       while(it.hasNext()){
           System.out.println(it.next());
      }
       //3.4使用列表迭代器
       ListIterator lit=list.listIterator();
       while(lit.hasNext()){
           //从前往后
           System.out.println(lit.nextIndex());
           System.out.println(lit.next());
      }
       //从后往前遍历
       while(lit.hasPrevious()){
           System.out.println(lit.previousIndex());
           System.out.println(lit.previous());
      }
​
       //4判断
       System.out.println(list.contains("oppo"));
       System.out.println(list.isEmpty());
​
       //5获取位置
       System.out.println(list.indexOf("apple"));
  }
}
​
/*
输出结果：
     5
     [apple, huawei, oppo, oppo, oppo]
     [apple, oppo, oppo]
     apple
     oppo
     oppo
     apple
     oppo
     oppo
     apple
     oppo
     oppo
     0
     apple
     1
     oppo
     2
     oppo
     2
     oppo
     1
     oppo
     0
     apple
     true
     false
     0
*/

1.列表迭代器

  1. 列表迭代器可以向前向后任意方向遍历。

  2. 还可以添加、删除、修改元素。

import java.util.ArrayList;
import java.util.List;
​
public class Demo04 {
   public static void main(String[] args) {
       List list=new ArrayList();
       //1.集合不能保存数字类型，在添加数字类型的时候会自动进行一个操作，自动装箱
       list.add(10);
       list.add(20);
       list.add(30);
       list.add(40);
       list.add(50);
       System.out.println(list.toString());
       //2.删除操作
       list.remove(new Integer(20));
       System.out.println(list.toString());
​
       //3补充方法sublist,含头部含尾
       List sublist=list.subList(0,2);
       System.out.println(sublist.toString());
​
​
  }
}
​
/*
输出结果：
     [10, 20, 30, 40, 50]
     [10, 30, 40, 50]
     [10, 30]
*/

2.List接口实现类

ArrayList

  • ArrayList【重点】

    • 数组结构实现，查询快，增删慢；

    • JDK1.2版本，运行效率快，线程不安全；

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
​
public class Demo05 {
   public static void main(String[] args) {
       ArrayList al=new ArrayList();
       //1.添加元素
       Student s1=new Student("a",10);
       Student s2=new Student("b",20);
       Student s3=new Student("c",30);
       al.add(s1);
       al.add(s2);
       al.add(s3);
       System.out.println(al.size());
       System.out.println(al.toString());
​
       //2.删除元素
       al.remove(new Student("a",10));//重写equals方法
       System.out.println(al.size());
​
       //3.遍历元素【重点】
       //3.1迭代器
       Iterator it=al.iterator();
       while(it.hasNext()){
           Student s=(Student)it.next();
           System.out.println(s.toString());
      }
       //3.2列表迭代器
       ListIterator lit=al.listIterator();
       while(lit.hasNext()){
           Student s=(Student)lit.next();
           System.out.println(s.toString());
      }
​
       while (lit.hasPrevious()){
           Student s=(Student)lit.previous();
          System.out.println(s.toString());
        }
​
       //4.判断
       System.out.println(al.contains(new Student("b",20)));
       System.out.println(al.isEmpty());
​
       //5.查找
       System.out.println(al.indexOf(new Student("b",20)));
  }
}
​
/*
输出结果：
     3
     [Student[name=a,age=10], Student[name=b,age=20], Student[name=c,age=30]]
     2
     Student[name=b,age=20]
     Student[name=c,age=30]
     Student[name=b,age=20]
     Student[name=c,age=30]
     Student[name=c,age=30]
     Student[name=b,age=20]
     true
     false
     0
     -1
*/

Vector

  • Vector

    • 数组结构实现，查询快、增删慢；

    • JDK1.0版本，运行效率慢、线程安全

import java.util.Enumeration;
import java.util.Vector;
​
public class Demo06 {
   public static void main(String[] args) {
       //创建集合
       Vector vec = new Vector();
       vec.add("草莓");
       vec.add("苹果");
       vec.add("香蕉");
       System.out.println(vec.size());
       //遍历
       //枚举器
       Enumeration en=vec.elements();
       while(en.hasMoreElements()){
           Object obj=en.nextElement();
           System.out.println(obj);
      }
       //判断
       System.out.println(vec.contains("西瓜"));
       //其他方法
  }
}
​
/*
输出结果：
     3
     草莓
     苹果
     香蕉
     false
*/

LinkedList

  • LinkedList

    • 链表结构实现，增删快、查询慢。

import java.util.Iterator;
import java.util.LinkedList;
​
public class Demo07 {
   public static void main(String[] args) {
       //创建对象
       LinkedList ll=new LinkedList();
       Student s1=new Student("a",10);
       Student s2=new Student("b",20);
       Student s3=new Student("c",30);
       Student s4=new Student("c",30);
       //添加
       ll.add(s1);
       ll.add(s2);
       ll.add(s3);
       System.out.println(ll.size());
       System.out.println(ll.toString());
       //删除
       ll.remove(new Student("a",10));
       System.out.println(ll.size());
       //遍历
       //for
       for(int i=0;i<ll.size();i++){
           System.out.println(ll.get(i));
      }
       //增强for
       for(Object o:ll){
           Student stu = (Student) o;
           System.out.println(stu);
      }
       //迭代器
       Iterator it=ll.iterator();
       while(it.hasNext()){
           Student s= (Student) it.next();
           System.out.println(s.toString());
      }
       //判断
       //获取
       System.out.println(ll.indexOf(s2));
  }
}
​
/*
输出结果：
     3
     [Student[name=a,age=10], Student[name=b,age=20], Student[name=c,age=30]]
     2
     Student[name=b,age=20]
     Student[name=c,age=30]
     Student[name=b,age=20]
     Student[name=c,age=30]
     Student[name=b,age=20]
     Student[name=c,age=30]
     0
*/

泛型和工具类

  • Java泛型是JDK1.5中引入的一个新特性，其本质是参数化类型，把类型作为参数传递。

  • 常见形式有泛型类、泛型接口、泛型方法。

  • 语法：<T,...>T称为类型占位符，表是一种引用类型。

  • 好处：

    1. 提高代码的重用性

    2. 防止类型转化异常，提高代码的安全性

⚠️注意

  1. 泛型只能是引用类型。

  2. 不同泛型类型对象之间不能相互复制。

1.泛型类

//创建一个泛型类
//泛型类
public class MyGeneric<T> {
   //使用泛型T
   //1.0创建变量
   T t;
   //2.0作为方法的参数
   public void show(T t){
       System.out.println(t);
  }
   //泛型作为方法的返回值
   public T getT(){
       return t;
  }
}
public class Demo08 {
   public static void main(String[] args) {
       //使用泛型类创建对象
       MyGeneric<String> mg=new MyGeneric<>();
       mg.t="hello";
       mg.show("你好");
       String s=mg.getT();
       System.out.println(s.toString());
​
       MyGeneric<Integer> mg2=new MyGeneric<>();
       mg2.t=20;
       mg2.show(30);
  }
}
​
/*
输出结果：
     你好
     hello
     30
*/

2.泛型接口

1.先创建一个泛型接口

//泛型接口
public interface MyInterface<T> {
    String name="张三";

    public T server(T t);
}

2.在创建一个接口实现类

可以在实现类中确定泛型类型

public class MyInterfaceImp implements MyInterface<String> {
​
   @Override
   public String server(String s) {
       System.out.println(s);
       return s;
  }
}

也可以不确定，继续创建一个泛型类

public class MyInterfaceImp2<T> implements MyInterface<T> {
   @Override
   public T server(T t) {
       System.out.println(t);
       return t;
  }
}

最终实现类里面，分别用两种类创建对象，发现他们的不同

public class Test {
    public static void main(String[] args) {
        MyInterfaceImp imp1=new MyInterfaceImp();
        imp1.server("xxxxxx");

        MyInterfaceImp2<String> imp2= new MyInterfaceImp2<>();
        imp2.server("aaaaaa");
    }

}

/*
输出结果：
      xxxxxx
      aaaaaa
*/

3.泛型方法

public class MyGenericMethod {
   //泛型方法
   public <T> T show(T t){
       System.out.println("泛型方法"+t);
       return t;
  }
}
public class Test {
   public static void main(String[] args) {
       MyGenericMethod mm=new MyGenericMethod();
       mm.show("中国加油");
       mm.show(200);
       mm.show(3.14);
  }
​
}
​
/*
输出结果：
     泛型方法中国加油
     泛型方法200
     泛型方法3.14
*/

4.泛型集合

  • 概念：参数化类型、类型安全的集合，强制集合元素的类型必须一致。

  • 特点：

    • 编译时即可检查，而非运行时抛出的异常。

    • 访问时，不必类型转换（拆箱）。

    • 不同泛型之间引用不能相互转换，泛型不存在多态。

public class Demo09 {
   public static void main(String[] args) {
       ArrayList<String> al=new ArrayList<>();
       al.add("xxx");
       al.add("yyy");
      // al.add(10);
       //al.add(20);
​
       for(String o:al){
           System.out.println(o);
      }
​
       ArrayList<Student> al2=new ArrayList<>();
       Student s1=new Student("a",1);
       Student s2=new Student("b",2);
       Student s3=new Student("c",3);
       al2.add(new Student("c",4));
       al2.add(s1);
       al2.add(s2);
       al2.add(s3);
​
       Iterator<Student> it= al2.iterator();
       while(it.hasNext()){
           Student s=it.next();
           System.out.println(s.toString());
      }
  }
}
​
/*
输出结果：
     xxx
     yyy
     Student[name=c,age=4]
     Student[name=a,age=1]
     Student[name=b,age=2]
     Student[name=c,age=3]
*/

Set接口与实现类

  • 特点：无序、无下标、元素不可重复。

  • 方法：全部继承于Collection接口

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
​
public class Demo01 {
   public static void main(String[] args) {
       Set<String> set=new HashSet<>();
       //1.添加数据
       set.add("苹果");
       set.add("华为");
       set.add("小米");
       System.out.println("数据个数"+set.size());
       System.out.println(set.toString());
       //2.删除
       //set.remove("小米");
       //3.遍历【重点】
       //1.增强for
       for(String str:set){
           System.out.println(str);
      }
​
       //2.迭代器遍历
       Iterator<String> it=set.iterator();
       while(it.hasNext()){
           System.out.println(it.next());
      }
​
       //4.判断
       System.out.println(set.contains("华为"));
       System.out.println(set.isEmpty());
  }
}
​
/*
输出结果：
     数据个数3
     [苹果, 华为, 小米]
     苹果
     华为
     小米
     苹果
     华为
     小米
     true
     false
*/

1.Hashset

  • 基于HashCode实现元素不重复

  • 当存入元素的哈希码相同时，会调用equals进行确认，如果是true，则拒绝存入后者。

import java.util.HashSet;
import java.util.Iterator;
​
public class Demo02 {
   public static void main(String[] args) {
       //演示hashset集合的使用
       //哈希表（数组+链表）
       HashSet<String> hs=new HashSet<>();
       hs.add("刘德华");
       hs.add("梁朝伟");
       hs.add("林志颖");
       hs.add("周润发");
       //hs.add("周润发");
       System.out.println(hs.size());
       System.out.println(hs.toString());
​
       hs.remove("刘德华");
       System.out.println(hs.toString());
​
       for(String str:hs){
           System.out.println(str);
      }
​
       Iterator<String> it=hs.iterator();
       while(it.hasNext()){
           System.out.println(it.next());
      }
​
       System.out.println(hs.contains("郭富城"));
       System.out.println(hs.isEmpty());
  }
}
​
/*
输出结果：
     4
     [梁朝伟, 林志颖, 周润发, 刘德华]
     [梁朝伟, 林志颖, 周润发]
     梁朝伟
     林志颖
     周润发
     梁朝伟
     林志颖
     周润发
     false
     false
*/
import java.util.HashSet;
import java.util.Iterator;
​
public class Demo03 {
   public static void main(String[] args) {
       HashSet<Person> hs=new HashSet<>();
       Person p1=new Person("刘德华",20);
       Person p2=new Person("李沐阳",30);
       Person p3=new Person("周润发",40);
       Person p4=new Person("王茜",50);
​
       hs.add(p1);
       hs.add(p2);
       hs.add(p3);
       hs.add(p4);
​
       System.out.println(hs.size());
       System.out.println(hs.toString());
​
       hs.add(new Person("王茜",50));//重写hashcode和equals方法
​
       hs.remove(p1);
       System.out.println(hs.toString());
​
       for(Person per:hs){
           System.out.println(per);
      }
​
       Iterator<Person> it=hs.iterator();
       while(it.hasNext()){
           System.out.println(it.next());
      }
​
       System.out.println(hs.contains(p1));
  }
}
​
/*
     4
     [Student[name=周润发,age=40], Student[name=刘德华,age=20], Student[name=王茜,age=50], Student[name=李沐阳,age=30]]
     [Student[name=周润发,age=40], Student[name=王茜,age=50], Student[name=李沐阳,age=30]]
     Student[name=周润发,age=40]
     Student[name=王茜,age=50]
     Student[name=李沐阳,age=30]
     Student[name=周润发,age=40]
     Student[name=王茜,age=50]
     Student[name=李沐阳,age=30]
     false
*/

⚠️为了避免添加重复的元素，Person类中需要重写equals方法和hashcode方法

 
  @Override
   public boolean equals(Object o) {
       if (this == o) return true;
       if (o == null || getClass() != o.getClass()) return false;
       Person person = (Person) o;
       return age == person.age &&
               Objects.equals(name, person.name);
  }
​
   @Override
   public int hashCode() {
       return Objects.hash(name, age);
  }

2.TreeSet

  • 基于排列顺序实现元素不重复。

  • 实现了SortedSet接口，对集合元素自动排序。

  • 元素对象的类型必须实现Comparable接口，指定排序规则。

  • 通过CompareTo方法确定是否为重复元素。

import java.util.Iterator;
import java.util.TreeSet;
​
public class Demo04 {
   public static void main(String[] args) {
       //treeset的使用
       TreeSet<String> ts = new TreeSet<>();
       //添加元素
       ts.add("good");
       ts.add("bonjour");
       ts.add("hello");
       ts.add("hi");
       System.out.println("元素个数" + ts.size());
       System.out.println(ts.toString());
​
       //添加重复元素
       ts.add("hi");
       System.out.println(ts.size());//失败
​
       //删除
       ts.remove("hi");
       System.out.println(ts.toString());
​
       //遍历
       for (String str : ts) {
           System.out.println(str);
      }
​
       Iterator<String> it=ts.iterator();
       while(it.hasNext()){
           System.out.println(it.next());
      }
  }
}
​
/*
输出结果:
     元素个数4
     [bonjour, good, hello, hi]
     4
     [bonjour, good, hello]
     bonjour
     good
     hello
     bonjour
     good
     hello
*/
import java.util.Iterator;
import java.util.TreeSet;
​
public class Demo05 {
   public static void main(String[] args) {
       TreeSet<Person> ts=new TreeSet<>();
       Person p1=new Person("李沐阳",21);
       Person p2=new Person("王茜",23);
       Person p3=new Person("李鑫文",19);
       Person p4=new Person("大哥",20);
       Person p5=new Person("大哥",20);
​
       //添加
       ts.add(p1);
       ts.add(p2);
       ts.add(p3);
       ts.add(p4);
       System.out.println("人数"+ts.size());
       System.out.println(ts.toString());
​
       ts.remove(new Person("大哥",20));
       System.out.println(ts.size());
​
       //遍历
       for(Person per:ts){
           System.out.println(per);
      }
​
       Iterator<Person> it=ts.iterator();
       while(it.hasNext()){
           System.out.println(it.next());
      }
  }
}
​
/*
输出结果：
     人数4
     [Student[name=大哥,age=20], Student[name=李沐阳,age=21], Student[name=李鑫文,age=19], Student[name=王茜,age=23]]
     3
     Student[name=李沐阳,age=21]
     Student[name=李鑫文,age=19]
     Student[name=王茜,age=23]
     Student[name=李沐阳,age=21]
     Student[name=李鑫文,age=19]
     Student[name=王茜,age=23]
*/

⚠️：需要实现Comparable接口

因此在Person类中必须实现接口且重写CompareTo方法

@Override
   public int compareTo(Object o) {
       Person p=(Person) o;
       int n1=this.getName().compareTo(p.getName());
       int n2=this.age-p.getAge();
​
       return n1==0?n2:n1;
  }

3.Comparator接口

  • Comparale：可比较

  • Comparator：实现定制比较（比较器）

import java.util.Comparator;
import java.util.TreeSet;
​
public class Demo06 {
   public static void main(String[] args) {
       TreeSet<Person> ts=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("李沐阳",21);
       Person p2=new Person("王茜",23);
       Person p3=new Person("李鑫文",19);
       Person p4=new Person("大哥",20);
       Person p5=new Person("大哥",20);
​
       ts.add(p1);
       ts.add(p2);
       ts.add(p3);
       ts.add(p4);
       ts.add(p5);
       System.out.println(ts.size());
       System.out.println(ts.toString());
  }
}
​
/*
输出结果：
     4
     [Student[name=李鑫文,age=19], Student[name=大哥,age=20], Student[name=李沐阳,age=21], Student[name=王茜,age=23]]
*/

案例（定制按长度比较）

import java.util.Comparator;
import java.util.TreeSet;
​
public class Demo07 {
   public static void main(String[] args) {
       TreeSet<String> ts=new TreeSet<>(new Comparator<String>() {
           @Override
           public int compare(String o1, String o2) {
               int n1=o1.length()-o2.length();
               int n2=o2.compareTo(o2);
               return n1==0?n2:n1;
          }
      });
​
       ts.add("helloworld");
       ts.add("iphone");
       ts.add("beijing");
       ts.add("tomcat");
       ts.add("xian");
       ts.add("changsha");
       ts.add("wuxi");
​
       for(String str:ts){
           System.out.println(str);
      }
​
  }
}
​
/*
输出结果：
     xian
     iphone
     beijing
     changsha
     helloworld
*/

Map接口与实现类

特点：

  • 用于存储任意键值对（Key-Value）

  • 键：无序、无下标、不允许重复（唯一）

  • 值：无序、无下标、允许重复

1.Map父接口

  • 特点：存储一对数据（Key- Value），无序、无下标、键不可以重复、值可以重复。

  • 方法：

    • V put(K key,V value)//将对象存入集合中，关联键值。key重复则覆盖原值。

    • Object get(Object key)//根据键获取对应的值。

    • Set<K>//返回所有key。

    • Collection<V> values()//返回包含所有值的Collection集合。

    • Set<Map.Entry<K.V>>//键值匹配的Set集合。

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
​
public class Demo01 {
   public static void main(String[] args) {
       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.remove("usa");
       System.out.println(map.size());
       //遍历元素
       //1:keySet()
       Set<String> ks=map.keySet();
       for(String str:ks){
           System.out.println(str+"="+map.get(str));
      }
​
       //2.使用entryset()
       Set<Map.Entry<String,String>> mn=map.entrySet();
       for(Map.Entry<String,String> entry:mn){
           System.out.println(entry.getKey()+entry.getValue());
      }
  }
}
​
/*
输出结果：
     3
     {usa=美国, uk=英国, cn=中国}
     2
     uk=英国
     cn=中国
     uk英国
     cn中国
*/

2.HashMap

  • JDK1.2版本，线程不安全，运行效率快，允许用null 作为key或者value。

  • Hashtable:JDK1.0版本，线程安全，运行效率慢；不允许null作为key或是value

package jihe3;
​
import java.util.HashMap;
import java.util.Map;
​
HashMap的使用；存储结构：（数组+链表+红黑树）
public class Demo02 {
   public static void main(String[] args) {
       //创建集合
       HashMap<Student,String> student=new HashMap<>();
       //添加元素
       Student s1=new Student(100,"孙悟空");
       Student s2=new Student(1200,"沙悟净");
       Student s3=new Student(1300,"猪八戒");
       student.put(s1,"北京");
       student.put(s2,"上海");
       student.put(s3,"南京");
       student.put(s3,"广州");
       student.put(new Student(1300,"猪八戒"),"广州");//重写hashcode和equals方法
       System.out.println("元素个数"+student.size());
       System.out.println(student.toString());
       //删除
       student.remove(s1);
       System.out.println("删除之后"+student.size());
       //3.1增强for遍历
       for(Student stu:student.keySet()){
           System.out.println(stu.toString()+"========"+student.get(stu));
      }
       //3.2entrySet()
       for(Map.Entry<Student,String> entry:student.entrySet()){
           System.out.println(entry.getKey()+"======="+entry.getValue());
      }
       //判断
       System.out.println(student.containsKey(s1));
       System.out.println(student.containsValue("南京"));
  }
}
​
/*
输出结果：
     元素个数3
     {Student{age=100, name='孙悟空'}=北京, Student{age=1300, name='猪八戒'}=广州, Student{age=1200, name='沙悟净'}=上海}
     删除之后2
     Student{age=1300, name='猪八戒'}========广州
     Student{age=1200, name='沙悟净'}========上海
     Student{age=1300, name='猪八戒'}=======广州
     Student{age=1200, name='沙悟净'}=======上海
     false
     false
*/

3.TreeMap

  • 实现了SortedMap接口（是Map的子接口），可以对key自动排序。

package jihe3;
​
import OOP.Demo17.Stu;
​
import java.util.Map;
import java.util.TreeMap;
​
public class Demo03 {
   public static void main(String[] args) {
       TreeMap<Student,String> tm=new TreeMap<>();
​
       Student s1=new Student(100,"孙悟空");
       Student s2=new Student(1200,"沙悟净");
       Student s3=new Student(1300,"猪八戒");
​
       tm.put(s1,"北京");
       tm.put(s2,"上海");
       tm.put(s3,"深圳");
       tm.put(new Student(1300,"猪八戒"),"深圳");
​
       System.out.println(tm.size());
       System.out.println(tm.toString());
​
       for(Student key:tm.keySet()){
           System.out.println(key+"========"+tm.get(key));
      }
​
       for (Map.Entry<Student,String> entry:tm.entrySet()){
           System.out.println(entry.getKey()+"======="+entry.getValue());
      }
  }
}
​
/*
输出结果：
3
     {Student{age=100, name='孙悟空'}=北京, Student{age=1200, name='沙悟净'}=上海, Student{age=1300, name='猪八戒'}=深圳}
     Student{age=100, name='孙悟空'}========北京
     Student{age=1200, name='沙悟净'}========上海
     Student{age=1300, name='猪八戒'}========深圳
     Student{age=100, name='孙悟空'}=======北京
     Student{age=1200, name='沙悟净'}=======上海
     Student{age=1300, name='猪八戒'}=======深圳
*/

4.Collections工具类

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

  • 方法：

    • public static void reverse(List<?> list)//反转集合中元素的顺序

    • public static void shuffle(List<?> list)//随机重置元素的顺序

    • public static void sort()List<?> list//升序排序（元素必须实现Comparable接口）

package jihe3;
​
import java.util.*;
​
public class Demo04 {
   public static void main(String[] args) {
       List<Integer> list=new ArrayList<>();
       list.add(20);
       list.add(30);
       list.add(40);
       list.add(50);
       list.add(60);
       //sort排序
       System.out.println("排序前"+list.toString());
       Collections.sort(list);
       System.out.println("排序后"+list.toString());
​
       //binarySearch查询
       int i=Collections.binarySearch(list,50);
       System.out.println(i);
​
       //copy复制
       List<Integer> list2=new ArrayList<>();
       for (int j=0;j<list.size();j++){
           list2.add(0);
      }
       Collections.copy(list2,list);
       System.out.println(list2.toString());
​
       //reverse反转
       Collections.reverse(list);
       System.out.println("反转后"+list.toString());
​
       //shuffle打乱
       Collections.shuffle(list);
       System.out.println("打乱后"+list.toString());
​
       //补充，list转为数组
       Integer[] arr=list.toArray(new Integer[0]);
       System.out.println(arr.length);
       System.out.println(Arrays.toString(arr));
​
       //数组转为集合
       String[] name={"张三","李四","王武"};
       List<String> list3=Arrays.asList(name);//集合是一个受限集合，不能添加和删除
       //基本类型转集合时，要把它写成包装类
       System.out.println(list3.toString());
  }
}
​
/*
输出结果：
     排序前[20, 30, 40, 50, 60]
     排序后[20, 30, 40, 50, 60]
     3
     [20, 30, 40, 50, 60]
     反转后[60, 50, 40, 30, 20]
     打乱后[30, 40, 20, 50, 60]
     5
     [30, 40, 20, 50, 60]
     [张三, 李四, 王武]
*/

这篇关于Java集合框架的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
栏目导航