Java集合--简单讲解

最新推荐文章于 2024-04-16 01:24:20 发布
最新推荐文章于 2024-04-16 01:24:20 发布
阅读量532 收藏 1
点赞数
分类专栏： JAVA基础 文章标签： java集合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L_Jun0112/article/details/76139731
版权

数组与集合

  • 在创建Java数组时，数组的长度必需要指定，数组一旦创建好之后，长度不改变，在同一个数组中只能存放同一种类型的数据（基本类型和引用类型）
  • 为了使程序能方便的存储和操作数目不固定的一组数据，JDK类库中提供了Java集合，所有的Java集合都在java.util包中，在集合中，只能存放对象的引用，而不能存放基本数据类型
  • Java集合主要有3种重要的类型：
    • List：是一个有序集合，可以存放重复的数据；
    • Set：是一个无序集合，不允许存放重复的数据；
    • Map：是一个无序集合，集合中包含一个键对象，一个值对象，键对象不允许重复，值对象可以重复（身份证号码–姓名）
      这里写图片描述

集合整体结构图

这里写图片描述

Collection和Iterator

  • Collection是List和Set的父接口，在Collection中定义了一些主要方法

这里写图片描述

List接口

  • List接口是一个有序集合，可以放入重复数据；
  • 下面主要有两个实现：ArrayList和LinkedList，他们都是有顺序的，也就是放进去是什么顺序，取出来还是什么顺序，也就是基于线性存储，可以看作是一个可变的数组
    • ArrayList：查询数据比较快，添加和删除数据比较慢（基于可变数组）
    • LinkedList：查询数据比较慢，添加和删除数据比较快（基于链表数据结构）
    • Vector：Vector已经不建议使用，Vector中的方法都是同步的，效率慢，已经被ArrayList取代
      这里写图片描述

List示例-String类型

public class Test01 {
    public static void main(String[] args) {
        String s1= new String("zhangsan");
        String s2= new String("lisi");
        String s3= new String("wangwu");
        List l = new ArrayList();
        l.add(s1);
        l.add(s2);
        l.add(s3);
        l.remove(1);
//      System.out.println(l.size());
//      System.out.println(l.contains(s2));
//      System.out.println(l.get(0));
//      System.out.println(l.get(1));
//      for (int i = 0; i < l.size(); i++) {
//          System.out.println(l.get(i));
//      }
        Iterator it = l.iterator(); //迭代器
        while(it.hasNext()){
            String s =(String) it.next();
            System.out.println(s);          
        }
    }
}

遍历集合的方法

Iterator迭代器
     Iterator<E> i =  list.iterator();
     public boolean hasNext();
     public E next();

这里写图片描述

forEach循环

这里写图片描述

泛型的初步

泛型能更早的发现错误，如类型转换错误，通常在运行期才会发现，如果使用泛型，那么在编译器将会发现，通常错误发现的越早，越容易调试，越容易减少成本

为什么使用泛型
    import java.util.*;
    public class GenericTest01 {
        public static void main(String[] args) {
            List l = new ArrayList();
            l.add(1);
            l.add(2);
            l.add(3);
            for (Iterator iter=l.iterator(); iter.hasNext();) {     
            //出现了java.lang.ClassCastException异常
            //这种转型错误在运行期被发现了
            //错误发现的越早越好，最好在编译器能发现类似的错误
            //如果想在编译器发现类似的错误，必须使用泛型
            String s = (String)iter.next();
            System.out.println(s);
        }
    }   
}
使用泛型解决示例
    import java.util.*;
    public class GenericTest02 {
        public static void main(String[] args) {
            List<Integer> l = new ArrayList<Integer>();
            l.add(1);
            l.add(2);
            l.add(3);   
            //不能将abc放到集合中，因为使用泛型，在编译器就可以返现错误
            //l.add("abc");
            for (Iterator<Integer> iter=l.iterator(); iter.hasNext();) {            
            //因为使用泛型，在编译器就可以发现错误
            //String s = (String)iter.next();
            //使用泛型可以不用进行强制转换
            //Integer s = (Integer)iter.next();
            //可以直接取得相应的元素，使用泛型返回的是真正的类型
            Integer s = iter.next();
            System.out.println(s);
        }
    }   
}

List示例-Student类型

    class Student {
        String no;
        String name;
        int age;
        public Student(String no,String name, int age) {
            this.no = no;
            this.name = name;
            this.age = age;
        }
        @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 (age != other.age)
                return false;
            if (name == null) {
            if (other.name != null)
                return false;
            } else if (!name.equals(other.name))
                return false;
            if (no == null) {
            if (other.no != null)
                return false;
            } else if (!no.equals(other.no))
                return false;
                return true;
        }
    }

    public class Test {
        public static void main(String[] args) {
            Student s1 = new Student("001","zs", 15);
            Student s2 = new Student("002","ls", 15);
            Student s3 = new Student("003","ww", 15);
            Student s4 = new Student("003","ww", 15);

            List l = new ArrayList();
            l.add(s1);
            l.add(s2);
            l.add(s3);
        //针对对象类型，如果要使用contains方法，必须要重写equals
        //  if(!l.contains(s4)){
        //      l.add(s4);          
        //  }
        //  
        //  System.out.println(l.size());
        //  for (Object o : l) {
        //      Student s = (Student)o;
        //      System.out.println(s.name);
        //  }
        //  
        //  System.out.println(l.contains(s4));

            Iterator it = l.iterator();
            while(it.hasNext()){
                Student s = (Student)it.next();
                System.out.println(s.name+":"+s.age);           
            }
        }
    }

List排序

  • void Collections.sort(List);

        String person1 = "zhang3";
    String person2 = "li4";
    String person3 = "wang5";

    List<String> list = new ArrayList<>();
    list.add(person1);
    list.add(person2);
    list.add(person3);

    Collections.sort(list);

    Iterator<String> it = list.iterator();
    while(it.hasNext()) {
        System.out.println(it.next());
}

    Student stu1=new Student("zhang2",20);
    Student stu2=new Student("zhang1",10);
    Student stu3=new Student("zhang1",30);

    List<Student> list1=new ArrayList<Student>();
    list1.add(stu1);
    list1.add(stu2);
    list1.add(stu3);

    //由于没有实现Comparable接口，无法通过编译
    Collections.sort(list); 

    Iterator<Student> it=list.iterator();
    while(it.hasNext()){
        Student student=it.next();
        System.out.println(student.getName());
    }

这里写图片描述

  • String+8种包装类默认已经实现了Comparable接口

  • 先按年龄排序，再按序号

     Student s = (Student)o;
 int i = this.age - s.age;
 if(i==0){
     return this.no.compareTo(s.no);
 }
 return i;
List自定义排序
  • Collection类的sort方法有个重载方法：sort(Listlist,Comparator
Comparator示例
  • 可以通过实现Comparator自定义排序规则
    这里写图片描述

这里写图片描述

Camparable和Comparator
  • 一个类实现了Camparable接口则表明这个类的对象之间是可以相互比较的，这个类对象组成的集合就可以直接使用sort方法排序，如果集合中使用比较功能，必须保证集合中的数据类型是一致的。
  • Comparator可以看成一种算法的实现，将算法和数据分离，Comparator也可以在下面两种环境下使用:
    • 1.类没有考虑到比较问题而没有实现Comparable，可以通过Comparator来实现排序而不必改变对象本身
    • 2.可以使用多种排序标准，比如升序、降序等

面试题

这里写图片描述

Set接口

  • Set：是一个无序集合，不允许放重复的数据，主要有两个实现类–HashSet和TreeSet
    这里写图片描述

哈希表

  • 哈希表是一种数据结构，哈希表能够提供快速存取操作。哈希表是基于数组的，所以也存在缺点，数组一旦创建将不能扩展
  • 正常的数组，如果需要查询某个值，需要对数组进行遍历，只是一种线性查找，查找的速度比较慢，如果数组中的元素值和下标能够存在明确的对应关系，那么通过数组元素的值就可以换算出数组元素的下标，通过下标就可以快速定位数组元素，这样的数组就是哈希表。一张哈希表：
    这里写图片描述

HashSet

  • HashSet中的数据是无序的不可重复的。HashSet按照哈希算法存取数据的，具有非常好的性能，它的工作原理是这样的：当向HashSet中插入数据的时候，他会调用对象的hashCode得到该对象的哈希码，然后根据哈希码计算出该对象插入到集合中的位置
    String person1=”zhang3”;
    String person2=”li4”;
    String person3=”wang5”;

    Set<String> set1=new HashSet<String>();
set1.add(person1);
set1.add(person2);
set1.add(person3);

Iterator<String> it=set1.iterator();
while(it.hasNext()){
    System.out.println(it.next());//输出是没有顺序的
}

  • HashSet 元素不可重复

    String person1="zhang3";
String person2="li4";
String person3="wang5";
String person3="wang5";

Set<String> set1=new HashSet<String>();
set1.add(person1);
set1.add(person2);
set1.add(person3);
set1.add(person4);

Iterator<String> it=set1.iterator();
while(it.hasNext()){
    System.out.println(it.next());
}

zhang3
wang5
li4

  • HashSet 没有成功的去除重复元素

     Student stu1=new Student(“zhang2",20);
Student stu2=new Student("zhang1",10);
Student stu3=new Student("zhang3",30);
Student stu4=new Student("zhang3",30);

Set<Student> set2=new HashSet<Student>();
set2.add(stu1);
set2.add(stu2);
set2.add(stu3);
set2.add(stu4);

Iterator<Student> it=set2.iterator();
while(it.hasNext()){
    Student student=it.next();
    System.out.println(student.getName());;
}

  • 是重写了Student的equals方法

    public class Student1 implements Comparable<Student>{
    String name;
    int age;
    @Override
    public boolean equals(Object obj){
        System.out.println("equals方法被调用");
        if(this==obj)   
            return true;
        if(obj==null)   
            return false;
        if(getClass()!=obj.getClass())  
            return false;
        Student1 other=(Student1)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;
    }
}

  • HashSet 仍然没有成功的去除重复元素，且equals没有调用

    Student stu1=new Student("sun2",20);
Student stu2=new Student("sun1",10);
Student stu3=new Student("sun3",30);
Student stu4=new Student("sun3",30);

Set<Student> set2=new HashSet<Student>();
set2.add(stu1);
set2.add(stu2);
set2.add(stu3);
set2.add(stu4);

Iterator<Student> it=set2.iterator();
while(it.hasNext()){
    Student student=it.next();
    System.out.println(student.getName());;
}

  • 采取HashSet存储对象类型数据，除了重写equals()，还必须要重写了hashCode方法后

    @Override
public int hashCode() {
    System.out.println("hashCode方法被调用了");
    final int prime = 31;
    int result = 1;
    result = prime * result + age;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    return result;
}
HashSet 怎样存储对象
  • Object中定义了 publicinthashCode()
  • HashSet怎样存储对象
    • 调用hashCode()
    • 当发现两个对象hashCode值相同时，再调用equals
  • HashCode方法的覆盖建议
    • 内容相同的对象，hashCode值一样
    • 最佳实践：不要自己提供hashCode值得算法，二是使用IDE自动生成，这是hashCode数学专家提供的算法，更可靠
    • hashCode和equals方法最好成对重写，不要只重写一个

TreeSet

  • SortedSet接口的实现类
  • 可以排序
  • 必须：元素实现Comparable接口；或调用TreeSet(Comparator

Map接口

  • 常用方法
    • key不可以重复、value可以重复
    • put(K key，Vvalue);
    • get(Object key);
    • remove(Object key);
    • clear();
    • isEmpty();
    • size();
      这里写图片描述

HashMap

  • HashMap的常规使用

    Map<String,String> map=new HashMap<>();
map.put("key1","value1");
map.put("key2","value2");
map.put("key3","value2");
map.put("key1","value4");//替换了第一次放入的value1
System.out.println(map.get(“key1”));//value4
System.out.println(map.get("key2")); //value2
System.out.println(map.get("key3")); //value2
System.out.println(map.get(“key8”));//null
  • HashMap的key也是通过Hash算法 过滤重复
  • Map的key一般都应用String
    • 如果想用自己写的类作为key值，那么就必须重写hashCode()方法和equals()方法，而且要保证对象不可变，也就是和String一样，一旦创建了这个对象，就不可修改。

Map的遍历

  • 值遍历

    Map<String,String> map=new HashMap<>();
map.put("key1","value1");
map.put("key2","value2");
map.put("key3","value2");
map.put("key1","value4");//替换了第一次放入的value1
Collection<String> collection=map.values();
for(String str:collection){
    System.out.println(str);
}

/*
* value2
* value2
* value4
*/

  • 键遍历

        Map<String,String> map=new HashMap<String,String>();
map.put("key1","value1");
map.put("key2","value2");
map.put("key3","value2");
map.put("key1","value4");//替换了第一次放入的value1
Set<String> set=map.keySet();
for(String str:set){
    System.out.println(str);
}
   /*
    * key3
    * key2
    * key1
    */

  • 键值遍历一

    Map<String,String> map=new HashMap<String,String>();
map.put("key1","value1");
map.put("key2","value2");
map.put("key3","value2");
map.put("key1","value4");//替换了第一次放入的value1
Set<String> set=map.keySet();
for(String key:set){
    System.out.println(key+":"+map.get(key));
}

   /*
    * key3:value2
    * key2:value2
    * key1:value4
    */

  • 键值遍历二

    • Entry是Map接口的一个内部接口，即子接口。 先有Map集合再有映射关系，是Map集合的内部事务 Map.Entry中存的是映射关系这种数据类型。

          Map<String,String> map=new HashMap<String,String>();
    map.put("key1","value1");
    map.put("key2","value2");
    map.put("key3","value2");
    map.put("key1","value4");//替换了第一次放入的value1
    Set<String> set=map.keySet();
    for(Entry<String,String> entry:map.entrySet()){
    System.out.println(entry.getKey()+":"+entry.getValue());
    }
   /*
    * key3:value2
    * key2:value2
    * key1:value4
    */

TreeMap

  • TreeMap 可以对key应用排序

     Map<String,String> map1=new TreeMap<String,String>();
map1.put("b", "value1");
map1.put("d", "value2");
map1.put("c", "value2");
map1.put("a", "value4");
for(Entry<String,String> entry:map.entrySet()){
System.out.println(entry.getKey()+":"+entry.getValue());
}
    /*
    * a:value4
    * b:value1
    * c:value2
    * d:value2
    */

  • TreeMap的key是通过Comparable接口 过滤重复 排序，也可以通过Comparator接口的实现类的对象来过滤重复排序

  • Map的key一般都应用String多

HashMap与Hashtable

  • Hashtable 与 HashMap的区别
    这里写图片描述

Collections工具类

  • Collections位于java.util包中，提供了一系列实用的方法，如：对集合排序，对集合中的内容查找等

    import java.util.*;
public class CollectionsTest01 {
    public static void main(String[] args) {
        List l = new ArrayList();
        l.add(5);
        l.add(1);
        l.add(4);
        l.add(2);
        for (Iterator iter=l.iterator(); iter.hasNext();) {
            System.out.println(iter.next());
        }
        System.out.println(“—List排序---");
        Collections.sort(l);
        for (Iterator iter=l.iterator(); iter.hasNext();) {
            System.out.println(iter.next());
        }
        System.out.println("-----");        
        Set set = new HashSet();
        set.add(10);
        set.add(1);
        set.add(4);
        set.add(9);
        //不能直接对set排序
        //Collections.sort(set);
        List setList = new ArrayList(set);
        Collections.sort(setList);
        for (Iterator iter=setList.iterator(); iter.hasNext();) {
            System.out.println(iter.next());
        }
        System.out.println(“---二分法查找--");
        int index = Collections.binarySearch(setList, 9);
        System.out.println("index=" + index);
        System.out.println(“---反转集合元素--");
        Collections.reverse(setList);
        for (Iterator iter=setList.iterator(); iter.hasNext();) {
            System.out.println(iter.next());
        }
    }   
}
苦修的木鱼
关注
专栏目录
java集合set初始化_Java集合--Set(基础)
weixin_31849265的博客
03-01 4444
1.Set上一篇，我们介绍Java中的List集合。本篇，让我们继续学习，来了解下Set集合；Set继承于Collection接口，是一个不允许出现重复元素，并且无序的集合，主要有HashSet和TreeSet两大实现类。在判断重复元素的时候，Set集合会调用hashCode()和equal()方法来实现。HashSet是哈希表结构，主要利用HashMap的key来存储元素，计算插入元素的hash...
Java 集合简单详解
Vivian_Arthur的博客
06-29 1008
简单来说，集合就是一个存放数据的容器，主要包括Collection和Map。1. Java的集合是java.util包中的重要内容。2.集合是Java数据结构的实现。在编写程序时，经常需要和各种数据打交道，为了处理这些数据而选用数据结构对于程序的运行效率是非常重要的。3.集合只能存放对象，即Object类的实例，Java中每一种基本数据类型都有对应的引用类型。并且集合可以存放多个不同类型，不限数量的数据类型。集合与数组不同，数组可以容纳对象和简单数据。
简单总结一下Java中的集合
BarryLee的博客
10-19 950
今天面试了深圳递四方，奇迹般的过了，在此纪念一下哈哈 技术面有不少问题没答好，其中一个就是集合，用了这么久的集合，脑袋里面还是没有一个系统的概念，当然要痛定思痛啦！ 上一个集合框架图 然后这个看起来有点混乱，先来一个简化的 这个图大概要能回答的出来，常用的还要熟悉 Collection下：List系 - 有序、元素允许重复；Set系 - 无序、元素不重复 Map下：HashMa...
java常用集合集合讲解
热门推荐
qq_42565099的博客
07-04 1万+
一、java集合系列        java的集合主要分为List列表、Set集合、Map映射、工具类(Iterator迭代器、Enumeration枚举类、Arrays和Collections )java中集合类的关系图       由此图可以看到，主要分为Collection和Map两大类：       1.Collection：是单列集合的顶层父类，是一个独立元素的序列，这些个元素都服从一条...
java集合简介
weixin_30343157的博客
03-05 58
Java数组的长度是固定的，在同一个数组中只能存放相同类型的数据。数组可以存放基本类型的数据，也可以存放引用类型的数据。 在创建数组时，必须明确指定数组的长度，数组一旦创建，其长度就不能被改变。在许多应用场合，一组数据的数目是不固定的，比如一个单位的员工数目是变化的，有老的员工跳槽，也有新的员工进来。 为了使程序能方便地存储和操纵数目不固定的一组数据，JDK类库提供了java集合，...
Java集合-Iterable
成凯的专栏
08-29 8227
Iterable接口表示一组对象，这些对象是Iterable的，这意味着可以迭代，这意味着实现Iterable接口，则可以迭代其元素，可以通过以下方式迭代Iterable对象，使用for-each循环，从Iterable获取Iterator或者通过Iterable的forEach()方法，下面会一一讲解。 用for-each循环等待的Iterable 第一种方法就是通过for-each 循环迭代，下面例子是如何通过for-each 循环迭代List。因为List继承了Collection接口，Col..
Java--collection.rar_SEP_java 集合
09-21
在"Java--collection.rar"这个压缩包中，我们可以找到名为"Java collection.pdf"的文件，它很可能是对Java集合框架的详细讲解。 首先，集合框架的基础是`Collection`接口，它是所有单值容器的父接口，包括`List`, `...
Java 实例 - 集合比较源代码-详细教程.zip
08-09
本教程通过源代码实例，深入讲解了Java集合框架中不同类型的集合（如List、Set、Queue等）以及它们之间的比较方法。 1. **集合接口** - `Collection`: 所有集合类的父接口，提供了一些基本操作，如添加元素、删除...
Java集合讲解(1)
最新发布
H1767410的博客
04-16 551
List类 ：元素按顺序存放，而且元素可以重复Set类 ：元素不按照顺序存放，而且还不能重复，每个元素的数据存放的位置是由该元素的Hashcode唯一决定，所以在集合中的位置也是固定的Map类: 它通过==键 : 值（key : Value）==来存放数据，而且也是没有顺序的由于篇幅原因，就不多做展示了《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！” />[外链图片转存中…(img-ZtF1vZPx-1713201847036)]
Java 实例 - 集合打乱顺序源代码-详细教程.zip
08-09
`Collections`是Java集合框架的一个实用工具类，提供了许多操作集合的方法，其中包括打乱顺序的功能。 `Collections.shuffle()`方法的使用方式如下： ```java List<Integer> list = new ArrayList(); list.add(1); ...
Java流--简单讲解
苦修的木鱼博客
07-28 2650
File类 IO 字节输入流 文件字节输入流FileInputStream 文件字节输入流FileInputStream示例 字节输出流OutputStream 文件字节输出流FileOutputStream 文件字节输出流FileOutputStream示例 字节缓冲流过滤流 字符编码 字符输入流 字符输出流 字符流 转换流 字符输入缓冲流过滤流 字符输出缓冲流过滤流 对象流及对象序列化 对象序列
网络编程和反射--简单讲解
苦修的木鱼博客
07-28 1502
网络基础 网络基础知识 网络用用的基本结构 网络三要素 网络分层 OSI的分层思想 网络通讯协议 TCP协议 Java中的ping 获取IP地址示例 Socket TCP编程 TCP编程示例 第一步服务器端创建ServerSocekt等待客户端请求 第二步客户端创建一个Socket对象发起请求建立与服务器端的连接 Socket通讯模型 反射的基本概念 Java中的类反射 reflection的工作机
Java中子类重写父类中的方法应注意的问题
苦修的木鱼博客
08-08 1009
重写规则之一 重写规则之二 重写规则之三 重写规则之四 重写规则之五 重写规则之六若想实现一个合格的重写方法,而不是重载，那么必须同时满足下面的要求：1.重写规则之一:重写方法不能比被重写的方法限制有更严格的访问级别。 比如：父类方法是protected访问权限，子类的重写方法可以是public 访问权限。 访问权限： 2.重写规则之二：参数列表必须与被重写方法的相同。 重写有个孪生的弟弟叫
Java进程--简单讲解
苦修的木鱼博客
07-28 888
线程和进程 线程开发 继承Thread类 实现Runnable接口 示例 两种方式对比 线程的状态 线程的调度与控制 线程优先级 sleep和join还有yeild Threadsleep Threadjoin Threadyield sleepjoinyeild关系 interrupt中断 如何正确的停止一个线程 为什么需要同步 线程同步 使用线程同步 线程同步后的状态 为每一个线程创建一个对象来
Java中的常用类--简单讲解
苦修的木鱼博客
07-25 618
java中的常用类 java中的常用类 Object类 getClass方法 toString方法 String类 String类的常用方法 案例 TestString类 StringBuffer和StringBuilder类 StringBuilder类实例 Math类 Math类实例 日期类Object类 java.lang包是应用程序的缺省导入包 java.lang.Object是所有类的根类
包装类和内部类--简单讲解
苦修的木鱼博客
07-25 526
包装类和内部类--简单讲解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

苦修的木鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值