当前位置:网站首页>集合

集合

2020-11-10 17:46:24 帅蜗

集合

什么是集合

  • 概念

    对象的容器,实现了对对象常用的操作

  • 和数组的区别

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

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

 

Collection体系

Collection父接口

特点:代表一组任意类型的对象,无序、无下标、不能重复。

创建集合 Collection collection = new ArrayList();

  • 常用方法

  1. 添加元素 collection.add();

  2. 删除元素

    collection.remove();

    collection.clear();

  3. 遍历元素(重点)

    1. 使用增强for(因为无下标)

      for(Object object : collection){ }

    2. 使用迭代器

       

      //hasNext(); 有没有下一个元素
      //next(); 获取下一个元素
      //remove(); 删除当前元素
      Iterator it = collection.iterator();
      while(it.hasNext()){
      String object = (String)it.next(); //强转
      // 可以使用it.remove(); 进行移除元素
      // collection.remove(); 不能用collection其他方法 会报并发修改异常
      }
  4. 判断 collection.contains(); collection.isEmpty();

  • 代码参考

    package com.pc.zjs;

    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;

    /**
    * Collection接口的使用
    *(1)添加元素
    *(2)删除元素
    *(3)遍历元素
    *(4)判断
    */
    public class Demo01 {
       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);
           //删除元素
           //collection.remove("榴莲");
           //collection.clear();删除全部
           //System.out.println("删除之后"+collection.size());
           //(3)遍历元素
           //3.1增强for
           System.out.println("------使用增强for-------");
           for(Object object:collection){
               System.out.println(object);
          }
           //3.2使用迭代器
           /*
           hasNext();有没有下一个元素
           next();获取下一个元素
           remove();删除当前元素
            */
           System.out.println("------使用迭代器--------");
           Iterator it=collection.iterator();
           while (it.hasNext()){
               String s = (String)it.next();
               System.out.println(s);
               //collection.remove(s);此处迭代器正在使用collection不允许对collection 进行操作
               it.remove();
          }
           System.out.println("元素个数"+collection.size());
           /*
           (4)判断
            */
           System.out.println(collection.contains("西瓜"));
           System.out.println(collection.isEmpty());
      }
    }

     

package com.pc.zjs;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
* Collection的使用:保存学生信息
*/
public class Demo02 {
   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.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迭代器
       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());
  }
}
package com.pc.zjs;

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 +
               '}';
  }
}

List子接口

特点:有序、有下标、元素可重复

创建集合对象 List list = new ArrayList<>( );

  • 常用方法

    1. 添加元素 list.add( ); 会对基本类型进行自动装箱

    2. 删除元素 可以用索引 list.remove(0)

      当删除数字与索引矛盾时 对数字强转

      list.remove((Object) 10)list.remove(new Integer(10))

    3. 遍历

      1. 使用for遍历

         

        for(int i = 0; i < list.size(); i++){
        sout(list.get(i));
        }
      2. 使用增强for

        for(Object list: collection){ }

      3. 使用迭代器

         

        Iterator it = collection.iterator();
        while(it.hasNext()){
        String object = (String)it.next(); //强转
        // 可以使用it.remove(); 进行移除元素
        // collection.remove(); 不能用collection其他方法 会报并发修改异常
        }
      4. 使用列表迭代器 (注意和迭代器区别)

         

        ListIterator li = list.listIterator();
        while(li.hasNext()){
        System.out.println(li.nextIndex() + ":" + li.next()); //从前往后遍历
        }

        while(li.hasPrevious()){
        System.out.println(li.previousIndex() + ":" + li.previous()); //从后往前遍历
        }
    4. 获取 list.indexOf( );

    5. 返回子集合 sublist(x, y); 左闭右开

      List subList = list.subList(1, 3); 返回索引 1、2

       

List实现类

  • ArrayList 【重点】

    • 数组结构实现,必须要连续空间,查询快、增删慢

    • jdk1.2版本,运行效率块、线程不安全

  • Vector

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

    • jdk1.0版本,运行

  • LinkedList

    • 双向链表结构实现,无需连续空间,增删快,查询慢

ArrayList

创建集合 ArrayList arrayList = new ArrayList<>();

  1. 添加元素 arrayList.add();

  2. 删除元素 arrayList.remove(new Student("name", 10));

这里重写了 equals(this == obj) 方法

public boolean equals(Object obj){
 //1 判断是不是同一个对象
 if(this == obj){
   return true;
}
 //2 判断是否为空
 if(obj == null){
   return false;
}
 //3 判断是否是Student类型
 if(obj instanceof Student){
   Student == (Student)obj;
   //4 比较属性
   if(this.name.equals(s.getName()) && this.age == s.getAge()){
     return true;
  }
}
 //5 不满足条件返回false
 return false;
}
  1. 遍历元素【重点】

    1. 使用迭代器

       

      Iterator it = arrayList.iterator();
      while(it.hasNext()){
      Student s = (Student)it.next(); //强转
      }
    2. 列表迭代器

       

      ListIterator li = arrayList.listIterator();
      while(li.hasNext()){
      Student s = (Student)li.next(); //从前往后遍历
      }

      while(li.hasPrevious()){
      Student s = (Student)li.previous();//从后往前遍历
      }
  2. 判断

    arrayList.contains();arrayList.isEmpty();

  3. 查找

    arrayList.indexof();

     

参考代码

package com.pc.zjs;

import java.util.ArrayList;
import java.util.List;

public class Demo04 {
   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((Object)20);
       //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());
  }
}


package com.pc.zjs;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

/**
* ArrayList的使用
*/
public class Demo05 {
   public static void main(String[] args) {
       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(s1);
       arrayList.remove(new Student("刘德华",20));
       System.out.println("删除之后"+arrayList.size());

       //3.遍历元素【重点】
       //3.1使用迭代器
       System.out.println("---使用迭代器---");
       Iterator it = arrayList.iterator();
       while (it.hasNext()){
           Student s = (Student)it.next();
           System.out.println(s.toString());
      }
       //3.2使用列表迭代器
       System.out.println("---使用列表迭代器---");
       ListIterator lit = arrayList.listIterator();
       while (lit.hasNext()){
           Student s = (Student)lit.next();
           System.out.println(s.toString());
      }
       System.out.println("---使用列表迭代器逆序---");
       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)));
  }
}
package com.pc.zjs;

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;
  }

}

ArrayList源码分析

DEFAULT_CAPACITY = 10; //默认容量
//注意:如果没有向集合中添加任何元素时,容量0,添加一个后,容量为10
//每次扩容是原来的1.5倍
elementData存放元素的数组
size 实际元素个数

Vector

创建集合 Vector vector = new Vector<>();

增加、删除、判断同上

遍历中枚举器遍历

Enumeration en = vector.elements();
while(en.hasMoreElements()){
 String o = (String)en.nextElement();
 sout(o);
}

package com.pc.zjs01;

import java.util.Enumeration;
import java.util.Vector;

/**
* 演示Vector的使用
*/
public class Demo01 {
   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);
      }
       //判断
       System.out.println(vector.contains("西瓜"));
       System.out.println(vector.isEmpty());
       //vector其他方法
       //firstElement,lastElement,elementAt();

  }
}

LinkedList

创建链表集合LinkedList li = new LinkedList<>();

常用方法与List一致

package com.pc.zjs01;

import com.pc.zjs.Student;

import java.util.Iterator;
import java.util.LinkedList;

/**
* LinkedList的使用
*
*/
public class Demo02 {
   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("---使用列表迭代器---");
       Iterator 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));
  }
}

 

泛型

  • 本质是参数化类型,把类型作为参数传递

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

  • 语法<T,...> T称为类型占位符,表示一种引用类型,可以写多个逗号隔开

  • 好处 1. 提高代码重用性 2. 防止类型转换异常,提高代码安全性

泛型类

package com.pc.zjs01;

/**
* 泛型类
* T是类型占位符,表示一种引用类型,如果编写多个用逗号隔开
*/
public class MyGeneric<T> {
   //使用泛型T
   //1.创建变量
   T t;
   //2泛型作为方法的参数
   public void show(T t){
       //T t1=new T();不能实例化
       System.out.println(t);
  }
   //3.泛型作为方法的返回值
   public T getT(){
       return t;
  }
}
package com.pc.zjs01;

public class TestGeneric {
   public static void main(String[] args) {
       //使用泛型类创建对象

       //泛型只能是引用类型,不同泛型类型对象之间不能相互赋值
       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();
  }
}

泛型接口

语法:接口名

注意:不能泛型静态常量

泛型方法

语法: 返回值类型

 

public class MyGenericMethod{
//泛型方法
public <T> T show(T t){
  sout("泛型方法" + t);
  return t;
}
}

//调用
MyGenericMethod myGenericMethod = new MyGenericMethod();
myGenericMethod.show("字符串");// 自动类型为字符串
myGenericMethod.show(200);// integer类型
myGenericMethod.show(3.14);// double类型

泛型集合

概念:参数化类型、类型安全的集合,强制集合元素的类型必须一致

特点:

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

  • 访问时,不必类型转换(拆箱)

  • 不同泛型之间应用不能相互赋值,泛型不存在多态

  • package com.pc.zjs01;

    import com.pc.zjs.Student;

    import java.util.ArrayList;
    import java.util.Iterator;

    public class Demo03 {
       public static void main(String[] args) {
           ArrayList<String> arrayList=new ArrayList();
           arrayList.add("xxx");
           arrayList.add("yyy");
    //       arrayList.add(10);
    //       arrayList.add(20);

           for(Object object:arrayList){
               String str=(String)object;
               System.out.println(str);
          }
           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());
          }

      }
    }

Set集合

特点:无序、无下标、元素不可重复

方法:全部继承自Collection中的方法

增、删、遍历、判断与collection一致

package com.pc.zjs02;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/**
* 测试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("小米");
//       set.clear();

       //3遍历
       //3.1使用增强for
       System.out.println("---增强for---");
       for(String string:set){
           System.out.println(string);
      }
       //3.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());
  }
}

 

HashSet 【重点】

存储结构:哈希表(数组+链表+红黑树)

package com.pc.zjs02;

import java.util.HashSet;
import java.util.Iterator;

/**
* HashSet集合的使用
* 存储结构:哈希表(数组+链表+红黑树)
*/
public class Demo02 {
   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("---增强for---");
       for(String string:hashSet){
           System.out.println(string);
      }
       //3.2使用迭代器
       System.out.println("---迭代器---");
       Iterator<String> it = hashSet.iterator();
       while (it.hasNext()){
           System.out.println(it.next());
      }
       //4判断
       System.out.println(hashSet.contains("郭富城"));
       System.out.println(hashSet.isEmpty());
  }
}

 

存储过程(重复依据)

  1. 根据hashCode计算保存的位置,如果位置为空,直接保存,若不为空,进行第二步

  2. 再执行equals方法,如果equals为true,则认为是重复,否则形成链表

    package com.pc.zjs02;

    import java.util.HashSet;
    import java.util.Iterator;

    /**
    * HashSet的使用
    *(1)根据hashCode计算保存的位置,如果位置为空,直接保存,若不为空,进行第二步
    * (2)再执行equals方法,如果equals为true,则认为是重复,否则形成链表
    */
    public class Demo03 {
       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(p1);//重复元素不会添加
           persons.add(new Person("梁朝伟",25));//可以添加

           System.out.println("元素个数"+persons.size());
           System.out.println(persons.toString());
           //2.删除元素
    //       persons.remove("刘德华");
    //       persons.clear();
    //       persons.remove(new Person("刘德华",20));//可以删除因为已经重写hashcode,equals方法

           //3遍历
           //3.1增强for
           System.out.println("---增强for--");
           for(Person person:persons){
               System.out.println(person.toString());
          }
           //3.2迭代器
           System.out.println("---迭代器---");
           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());
      }
    }
    package com.pc.zjs02;

    public class Person {
       private String name;
       private int age;

       public Person() {
      }

       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() {
           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;
      }
    }

     

特点

  • 基于HashCode计算元素存放位置

    • 利用31这个质数,减少散列冲突

      • 31提高执行效率 31 * i = (i << 5) - i 转为移位操作

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

新建集合 HashSet<String> hashSet = new HashSet<String>();

添加元素 hashSet.add( );

删除元素 hashSet.remove( );

遍历操作

1. 增强for for( type type : hashSet)

2. 迭代器 Iterator<String> it = hashSet.iterator( );

判断 hashSet.contains( ); hashSet.isEmpty();

TreeSet

特点

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

  • 实现SortedSet接口,对集合元素自动排序

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

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

存储结构:红黑树

创建集合 TreeSet<String> treeSet = new TreeSet<>()

添加元素 treeSet.add();

删除元素 treeSet.remove();

遍历 1. 增强for 2. 迭代器

判断 treeSet.contains();

补充:TreeSet集合的使用

Comparator 实现定制比较(比较器)

Comparable 可比较的

package com.pc.zjs02;

import java.util.Iterator;
import java.util.TreeSet;

/**
* TreeSet的使用
* 存储结构:红黑树
*/
public class Demo04 {
   public static void main(String[] args) {
       //创建集合
       TreeSet<String> treeSet=new TreeSet<>();
       //1添加元素
       treeSet.add("xyz");
       treeSet.add("abc");
       treeSet.add("hello");
       System.out.println("元素个数"+treeSet.size());
       System.out.println(treeSet.toString());

       //2删除元素
//       treeSet.remove("xyz");
//       System.out.println("删除之后"+treeSet.size());
//       treeSet.clear();
       //3遍历元素
       //3.1增强for
       System.out.println("---增强for---");
       for(String string:treeSet){
           System.out.println(string);
      }//3.2迭代器
       System.out.println("---迭代器---");
       Iterator<String> it = treeSet.iterator();
       while (it.hasNext()){
           System.out.println(it.next());
      }
       //4判断
       System.out.println(treeSet.contains("abc"));
       System.out.println(treeSet.isEmpty());
  }
}
package com.pc.zjs02;

import java.util.Iterator;
import java.util.TreeSet;

/**
* 使用treeset保存数据
* 存储结构:红黑树
* 要求:元素必须要实现comparable接口,compareTo()方法返回值为0,判定为重复元素
*/
public class Demo05 {
   public static void main(String[] args) {
       //创建集合
       TreeSet<Person> persons=new TreeSet<>();
       //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);
       System.out.println("元素个数"+persons.size());
       System.out.println(persons.toString());
       //2删除
//       persons.remove(new Person("梁朝伟",22));
//       persons.clear();
       //3遍历
       //3.1增强for
       System.out.println("---增强for---");
       for(Person person:persons){
           System.out.println(person);
      }
       //3.2迭代器
       System.out.println("---迭代器---");
       Iterator<Person> it = persons.iterator();
       while (it.hasNext()){
           System.out.println(it.next());
      }
       //4判断
       System.out.println(persons.contains(p1));
       System.out.println(persons.isEmpty());
  }
}
package com.pc.zjs02;

public class Person implements Comparable<Person>{
   private String name;
   private int age;

   public Person() {
  }

   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() {
       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;
  }

   //先按姓名比然后再按年龄比
   @Override
   public int compareTo(Person o) {
       int n1=this.getName().compareTo(o.getName());
       int n2=this.age-o.getAge();
       return n1==0?n2:n1;
  }
}

TreeSet案例

package com.pc.zjs02;

import java.util.Comparator;
import java.util.TreeSet;

/**
* 需求:使用TreeSet集合实现字符串按照长度进行排序
* helloworld zhang lisi wangwu beijing xian nanjing
* Comparator接口实现定制比较
*/
public class Demo06 {
   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());
  }
}

Map集合

Map接口的特点

1. 用于存储任意键值对(key - value)
2. 键:无序、无下标、不允许重复(唯一)
3. 值:无序、无下标、允许重复

方法:

1. V put(K key, V value) 将对象存到集合中,关联键值
2. Object get(Object key) 根据键获得对应的值
3. Set<K> 返回所有的Key
4. Collection<V> values() 返回包含所有值的Collection集合
5. Set<Map.Entry<K, V>> 键值匹配的Set集合

Map接口的使用

package com.pc.zjs03;

import java.util.HashMap;
import java.util.Map;

/**
* Map接口的使用
* 特点;(1)存储键值对(2)键不能重复 ,值可以重复(3)无序
*/
public class Demo01 {
   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("泰国"));
  }
}

HashMap

存储结构:哈希表(数组+链表+红黑树)

使用key可使hashcode和equals作为重复

增、删、遍历、判断与上述一致

原码分析总结:

  1. HashMap刚创建时,table是null,节省空间,当添加第一个元素时,table容量调整为16

  2. 当元素个数大于阈值(16*0.75 = 12)时,会进行扩容,扩容后的大小为原来的两倍,目的是减少调整元素的个数

  3. jdk1.8 当每个链表长度 >8 ,并且数组元素个数 ≥64时,会调整成红黑树,目的是提高效率

  4. jdk1.8 当链表长度 <6 时 调整成链表

  5. jdk1.8 以前,链表时头插入,之后为尾插入

    package com.pc.zjs03;

    import java.util.HashMap;
    import java.util.Map;

    /**
    * HashMap集合
    * 存储结构:哈希表(数组+链表+红黑树)
    * 使用key的hashcode和equals作为重复依据
    */
    public class Demo02 {
       public static void main(String[] args) {
           //创建集合
           HashMap<Student,String> students=new HashMap<Student,String>();
           //添加元素
           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(new Student("沙僧",1002),"杭州");
           System.out.println("元素个数"+students.size());
           System.out.println(students.toString());

           //2删除元素
           students.remove(s1);
           students.clear();
           System.out.println("删除之后"+students.size());
           //3遍历
           //3.1使用keySet()
           for(Student key:students.keySet()){
               System.out.println(key.toString()+"======"+students.get(key));
          }
           //3.2使用entrySet();
           for(Map.Entry<Student,String>entry:students.entrySet()){
               System.out.println(entry.getKey()+"-------"+entry.getValue());
          }
           //4判断
           //System.out.println(students.containsKey(s1));
           System.out.println(students.containsKey(new Student("孙悟空",100)));
           System.out.println(students.containsValue("杭州"));
      }
    }
    package com.pc.zjs03;

    public class Student implements Comparable<Student>{
       private String name;
       private int stuNo;

       public Student() {
      }

       public Student(String name, int age) {
           this.name = name;
           this.stuNo = age;
      }

       public String getName() {
           return name;
      }

       public void setName(String name) {
           this.name = name;
      }

       public int getStuNo() {
           return stuNo;
      }

       public void setStuNo(int age) {
           this.stuNo = age;
      }

       @Override
       public String toString() {
           return "Student{" +
                   "name='" + name + '\'' +
                   ", age=" + 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 int compareTo(Student o) {
           int n2=this.stuNo-o.getStuNo();
           return n2;
      }
    }


     

Hashtable

线程安全,运行效率慢;不允许null作为key或是value

Properties

hashtable的子类,要求key和value都是string,通常用于配置文件的读取

TreeMap

实现了SortedMap接口(是map的子接口),可以对key自动排序

package com.pc.zjs03;

import java.util.Map;
import java.util.TreeMap;

public class Demo03 {
   public static void main(String[] args) {
       //创建集合
           TreeMap<Student,String> treeMap=new TreeMap<Student,String>();
           //添加元素
           Student s1=new Student("孙悟空",100);
           Student s2=new Student("猪八戒",101);
           Student s3=new Student("沙僧",102);
           treeMap.put(s1,"北京");
           treeMap.put(s2,"上海");
           treeMap.put(s3,"杭州");
           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)));
  }
}

Collection工具类

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

直接二分查找int i = Collections.binarySearch(list, x); 成功返回索引

其他方法 : copy复制、reverse反转、shuffle打乱

补充:

package com.pc.zjs03;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

/**
* 演示Collection工具类的使用
*/
public class Demo04 {
   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,12);
       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[0]);
       System.out.println(arr.length);
       System.out.println(Arrays.toString(arr));
       //数组转换成集合
       System.out.println("---数组转换成集合---");
       String[] names={"张三","李四","王五"};
       //集合是一个受限集合,不能添加和删除
       List<String> list2=Arrays.asList(names);

       System.out.println(list2);
       Integer[] nums={100,200,300,400,500};
       List<Integer> list3 = Arrays.asList(nums);
       System.out.println(list3);

  }
}

总结

  • 集合的概念:

    对象的容器,和数组类似,定义了多个对象进行操作的常用方法

  • List集合

    有序,有下标元素可以重复,ArrayList,LinkedList,Vector

  • Set集合

    无序,无下标,元素不可以重复HashSet,TreeSet

  • Map集合

    存储一对数据,无序,无下标,键不可重复,值可以重复HashMap,HashTable,TreeMap

  • Collections

集合工具类,定义了除了存取以外的集合常用方法

版权声明
本文为[帅蜗]所创,转载请带上原文链接,感谢
https://www.cnblogs.com/zjsQ/p/13955051.html