我的Java集合笔记

最新推荐文章于 2024-08-23 15:54:50 发布
最新推荐文章于 2024-08-23 15:54:50 发布
阅读量113 收藏
点赞数
文章标签： java Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50900566/article/details/129130095
版权

集合

生活中也有集合的概念，是一个动词

Java中的集合是一个名词，是数据的一种容器，用于容纳数据

java提供了完整的集合框架

问题1：什么时候需要一个容纳数据的容器，也就是集合对象呢？

当存储的数据个数不确定的时候需要用

问题2：如果只是为了容纳数据，可以是直接使用数组，为什么要学习集合？

数组使用起来不方便，在数据个数不确定的场合，数组使用起来不是很方便

总结：

对不确定的有关系的数据进行相同逻辑处理的场合，使用集合是一个不错的选择

集合分类

根据数据的不同，Java集合分为两大体系

  1. 单一数据体系：Collection接口定义了相关的规则

  1. 成对出现的数据体系：Collection接口定义了相关的规则

所谓的成对的数据，就是2个数据有关系，可以根据第一个数据关联到第二个数据

也称之为键值对数据,(123123,zhangsan) ->(key , value)

Collection和Map接口

Collection常用的子接口

  • List：按照插入顺序保存数据，数据可以重复

具体的实现类：ArrayList，LinkedList

  • Set：集，无序保存，数据不能重复

具体的实现类：HashSet

  • Queue：队列

具体的实现类：ArrayBlockingQueue

Map常用的子接口

  • 具体的实现：HashMap,Hashtable

Collection - ArrayList

ArrayList: Array + List

List：列表，清单，按照插入顺序进行存储

Array：数组，阵列

创建第一个集合对象

ArrayListlist=newArrayList();

ArrayList的增删改查

//增加数据 add方法可以增加数据，只要将数据作为参数传递到add方法即可

//添加数据时，如果集合中没有任何的数据，那么底层会创建长度为10的数组

        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
        list.add("zhaoliu");
        //获取集合中数据的条数
        System.out.println(list.size());
        //获取指定位置的数据，采取索引的方式
        System.out.println(list.get(1));
        //打印集合对象
        System.out.println(list);
        //遍历集合中的数据
        for (inti=0; i<list.size(); i++) {
            System.out.println("集合中的数据："+list.get(i));
        }
        //如果循环遍历集合数据时，不关心数据的位置，那么可以采用特殊的for循环
        for(Objectobj : list){
            System.out.println(obj);
        }
        //将指定位置的数据进行修改，set方法需要传递两个参数，第一个参数表示数据的位置，第二个参数修改的值。
        //方法会返回结果，这个结果就是更新前的值
        list.set(1,"llllaaa");
​
        //删除数据
        list.remove(1);

ArrayList常用方法

ArrayListlist=newArrayList();
​
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
​
        //add方法可以传递两个参数的，第一个参数表示数据增加的位置（索引）.第二个参数表示数据
        list.add(1,"shuaige");
​
        ArrayList<Object>list1=newArrayList<>();
        list1.add("a");
        list1.add("b");
        list1.add("c");
        list.addAll(list1);
        System.out.println(list);
​
        //size方法表示集合内部数据的数量
        System.out.println(list.size());
        //判断集合是否为空
        System.out.println(list.isEmpty());
        //清空集合
//        list.clear();
        //删除指定集合中的数据
//        list.removeAll(list1);
        //判断是否存在某条数据
        list.contains("shuaige");
        //判断数据在集合中的索引位置，如果不存在表示-1
        //如果有两个相同的数据返回的是数据在索引中的第一位置
        System.out.println(list.indexOf("zhangsan"));
        //将集合转为数组
        Object[] objects=list.toArray();
        //克隆,复制新集合
        Objectclone=list.clone();
        ArrayListlist2= (ArrayList) clone;

Collection-LinkedList

LinkedList : Linked + List

Linked: 连接 数据存储和管理的一种方式

LinkedList基本操作

LinkedListlist=newLinkedList();
​
        //增加数据
        list.add("zhangsan");
        list.addFirst("lisi");
        list.add(1,"wangwu");
​
        //获取数据
        System.out.println(list.getFirst());
        System.out.println(list.getLast());
​
        //遍历数据
        System.out.println(list.get(1));
        for (inti=0; i<list.size(); i++) {
            //System.out.println(list.get(i));
        }
        //增强for循环
        for (Objectobj :list){
            System.out.println(obj);
        }
        //修改数据
        list.set(1,"lalala");
        //删除数据
        list.remove("zhangsan");
        //打印集合数据
        System.out.println(list);
LinkedList常用方法
LinkedListlist=newLinkedList();
        LinkedListlist1=newLinkedList();
​
        //追加数据
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
        //向指定位置追加数据
        list.add(1,"zhaoliu");
        list.addFirst("1");
        list.addLast("2");
        //向集合里面追加集合
        list.addAll(list1);
        //删除
        list.remove();//删除第一个
        list.removeFirst();
        list.removeLast();
        list.remove(1);
​
        System.out.println(list.size());
        System.out.println(list.isEmpty());
        list.clear();
        list.contains("a");
        list.element();//获取第一个数据
        list.push("aaaa"); //添加到第一个
        list.pop(); //弹出数据

泛型

泛型概述：

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

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

  • 语法：

  • <T,…> T称为类型占位符，表示一种引用类型。

  • 好处：

  • 提高代码的重用性。

  • 防止类型转换异常，提高代码的安全性。

泛型类

/**
* 泛型类
* 语法：类名<T>
* T是类型占位符，表示一种引用类型，编写多个使用逗号隔开
* 
*/
publicclassmyGeneric<T>{
    //1.创建泛型变量
    //不能使用new来创建，因为泛型是不确定的类型，也可能拥有私密的构造方法。
    Tt;
    //2.泛型作为方法的参数
    publicvoidshow(Tt) {
        System.out.println(t);
    }
    //泛型作为方法的返回值
    publicTgetT() {
        returnt;
    }
}
/**
* 注意：
* 1.泛型只能使用引用类型
* 2.不同泛型类型的对象不能相互赋值
*/
publicclasstestGeneric {
    publicstaticvoidmain(String[] args) {
        //使用泛型类创建对象
        myGeneric<String>myGeneric1=newmyGeneric<String>();
        myGeneric1.t="tang";
        myGeneric1.show("he");
        
        myGeneric<Integer>myGeneric2=newmyGeneric<Integer>();
        myGeneric2.t=10;
        myGeneric2.show(20);
        Integerinteger=myGeneric2.getT();
    }
}

​

泛型接口

/**
* 泛型接口
* 语法：接口名<T>
* 注意：不能创建泛型静态常量
*/
publicinterfaceMyInterface<T> {
    //创建常量
    StringnameString="tang";
    
    Tserver(Tt);
}
/**
* 实现接口时确定泛型类
*/
publicclassMyInterfaceImplimplementsMyInterface<String>{
    @Override
    publicStringserver(Stringt) {
        System.out.println(t);
        returnt; 
    }
}
//测试
MyInterfaceImplmyInterfaceImpl=newMyInterfaceImpl();
myInterfaceImpl.server("xxx");
//xxx
/**
* 实现接口时不确定泛型类
*/
publicclassMyInterfaceImpl2<T>implementsMyInterface<T>{
    @Override
    publicTserver(Tt) {
        System.out.println(t);
        returnt;
    }
}
COPY//测试
MyInterfaceImpl2<Integer>myInterfaceImpl2=newMyInterfaceImpl2<Integer>();
myInterfaceImpl2.server(2000);
//2000

泛型方法

/**
* 泛型方法
* 语法：<T> 返回类型
*/
publicclassMyGenericMethod {
    public<T>voidshow(Tt) {
        System.out.println("泛型方法"+t);
    }
}
COPY//测试
MyGenericMethodmyGenericMethod=newMyGenericMethod();
myGenericMethod.show("tang");
myGenericMethod.show(200);
myGenericMethod.show(3.14);

泛型集合

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

  • 特点

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

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

  • 不同泛型指尖引用不能相互赋值，泛型不存在多态。

比较器

publicclassCompareDemo {
    publicstaticvoidmain(String[] args) {
        ArrayListarrayList=newArrayList();
        arrayList.add(1);
        arrayList.add(3);
        arrayList.add(2);
​
        arrayList.sort(newNumberComparator());
    }
}
​
classNumberComparatorimplementsComparator<Integer> {
    @Override
    publicintcompare(Integero1, Integero2) {
        //如果第一个数比第二个数要大，那么返回结果为正数，表示升序
        //如果第一个数比第二个数要小，那么返回结果为负数，表示升序
        //如果第一个数和第二个数相等，那么返回0
        returno1-o2;
    }
}
}

ArrayList和LinkerList对比

  • ArrayList：必须开辟连续空间，查询快，增删慢。

  • LinkedList：无需开辟连续空间，查询慢，增删快。

HashSet

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

  • 方法：全部继承自Collection中的方法。

  • 底层结构：数组+链表

基本操作如下：

HashSetset=newHashSet();
//增加数据
set.add("zhangsan");
set.add("zhangsan");
set.add("lisi");
set.add("wangwu");
//修改数据 不能修改数据
​
//删除数据
set.remove("wangwu");
//查询数据
for (Objecto : set) {
    System.out.println(o);

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

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

注：hashSet存储过程：

根据hashCode计算保存的位置，如果位置为空，则直接保存，否则执行第二步。执行equals方法，如果方法返回true，则认为是重复，拒绝存储，否则形成链表。存储过程实际上就是重复依据，要实现“注”里的问题，可以重写hashCode和equals代码：

@Override
publicinthashCode() {
    finalintprime=31;
    intresult=1;
    result=prime*result+age;
    result=prime*result+ ((name==null) ?0 : name.hashCode());
    returnresult;
}
@Override
publicbooleanequals(Objectobj) {
    if (this==obj)
        returntrue;
    if (obj==null)
        returnfalse;
    if (getClass() !=obj.getClass())
        returnfalse;
    Personother= (Person) obj;
    if (age!=other.age)
        returnfalse;
    if (name==null) {
        if (other.name!=null)
            returnfalse;
    } elseif (!name.equals(other.name))
        returnfalse;
    returntrue;
}

Queue

// ArrayBlockingQueue: Array + Blocking(阻塞，堵住） + queue
        ArrayBlockingQueuequeue=newArrayBlockingQueue(3);
//        queue.add("zhangsan");
//        queue.add("lisi");
//        queue.add("wangwu");
//        queue.add("wangwu");//发生错误，Queue full
//        queue.put("zhangsan");
//        System.out.println("第一个人挂号");
//        queue.put("lisi");
//        System.out.println("第二个人挂号");
//        queue.put("wangwu");
//        System.out.println("第三个人挂号");
//        queue.put("zhaoliu");
//        System.out.println("第四个人挂号");
        //添加数据
        queue.offer("zhangsan");
        queue.offer("zhangsan");
        queue.offer("zhangsan");
        //取数据
        queue.poll();//返回布尔类型
        queue.take();//会阻塞 等进入再取
        System.out.println(queue);

HashMAP

HashMap一旦循环遍历时，那么增删数据，就会发生错误

publicclassStudent {
  privateStringname;
  privateintid; 
  publicStudent(Stringname, intid) {
      super();
      this.name=name;
      this.id=id;
  }
  publicStringgetName() {
      returnname;
  }
  publicvoidsetName(Stringname) {
      this.name=name;
  }
  publicintgetId() {
      returnid;
  }
  publicvoidsetId(intid) {
      this.id=id;
  }
  @Override
  publicStringtoString() {
      return"Student [name="+name+", age="+id+"]";
  }
  }
HashMap<Student, String>hashMap=newHashMap<Student, String>();
      Students1=newStudent("tang", 36);
      Students2=newStudent("yu", 101);
      Students3=newStudent("he", 10);
      //1.添加元素
      hashMap.put(s1, "成都");
      hashMap.put(s2, "杭州");
      hashMap.put(s3, "郑州");
      //添加失败，但会更新值
      hashMap.put(s3,"上海");
      //添加成功，不过两个属性一模一样；
      //注：假如相同属性便认为是同一个对象，怎么修改？
      hashMap.put(newStudent("he", 10),"上海");
      System.out.println(hashMap.toString());
      //2.删除元素
      hashMap.remove(s3);
      System.out.println(hashMap.toString());
      //3.遍历
      //3.1 使用keySet()遍历
      for (Studentkey : hashMap.keySet()) {
          System.out.println(key+" "+hashMap.get(key));
      }
      //3.2 使用entrySet()遍历
      for (Entry<Student, String>entry : hashMap.entrySet()) {
          System.out.println(entry.getKey()+" "+entry.getValue());
      }
      //4.判断
      //注：同上
      System.out.println(hashMap.containsKey(newStudent("he", 10)));
      System.out.println(hashMap.containsValue("成都"));

HashMap和Hashtable区别

  1. 实现方式不一样：继承父类不同

  1. 底层结构容量不同：HashMap(16),Hashtable(11)

  1. HashMap的K,V都可以为null ， Hashtable不可以

  1. HashMap的数据定位采用的是Hash算法，但是Hashtable采用的是Hashcode

  1. HashMap性能较高，Hashtable性能较低

迭代器

HashMap<String, Integer>map=newHashMap<String,Integer>();
        map.put("zs",1);
        map.put("ls",2);
        map.put("ww",3);
        Set<String>keys=map.keySet();
        //迭代器
        Iterator<String>iterator=keys.iterator();
        // hasNext方法用于判断是否存在下一条数据
        while (iterator.hasNext()){
            //获取下一条数据
            Stringkey=iterator.next();
            if ("ls".equals(key)){
                //remove方法只能对当前数据进行删除
                iterator.remove();
            }
            System.out.println(map.get(key));
        }

工具类

List<Integer>list=newArrayList<Integer>();
        list.add(20);
        list.add(10);
        list.add(30);
        list.add(90);
        list.add(70);
        
        //sort排序
        System.out.println(list.toString());
        Collections.sort(list);
        System.out.println(list.toString());
        System.out.println("---------");
        
        //binarySearch二分查找
        inti=Collections.binarySearch(list, 10);
        System.out.println(i);
        
        //copy复制
        List<Integer>list2=newArrayList<Integer>();
        for(inti1=0;i1<5;++i1) {
            list2.add(0);
        }
        //该方法要求目标元素容量大于等于源目标
        Collections.copy(list2, list);
        System.out.println(list2.toString());
        
        //reserve反转
        Collections.reverse(list2);
        System.out.println(list2.toString());
        
        //shuffle 打乱
        Collections.shuffle(list2);
        System.out.println(list2.toString());
        
        //补充：list转成数组
        Integer[] arr=list.toArray(newInteger[0]);
        System.out.println(arr.length);
        //补充：数组转成集合 
        String[] nameStrings= {"tang","he","yu"};
        //受限集合，不能添加和删除
        List<String>list3=Arrays.asList(nameStrings);
        System.out.println(list3);
java大王
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java集合类学习笔记汇总
L17707500994的博客
10-31 178
数组和集合的区别: 结合结构图: 迭代器(iterator): Iterator 接口提供遍历任何 Collection 的接口,Iterator 的特点是只能单向遍历, 迭代器遍历集合实例: package collection; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class CollectionIteratorDemo { pu
笔记总结-Java集合
weixin_54236608的博客
07-17 287
Java集合
十三：集合
热门推荐
本人主攻Java，希望自己能成为出色的程序员。
02-06 4万+
跳转到总目录 文章目录01、Java 集合框架概述1.1、集合框架与数组的对比及概述1.2、集合框架涉及到的API02、Collection接口方法2.2、Collection接口中的常用方法12.3、Collection接口中的常用方法22.4、Collection接口中的常用方法32.5、Collection接口中的常用方法403、Iterator迭代器接口3.1、使用Iterator遍历Collection3.2、迭代器Iterator的执行原理3.3、Iterator遍历集合的两种错误写法3.4、I
JAVA集合类笔记
chenqipc的专栏
10-15 532
-------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ---------------------- 集合类：          面向对象的语言对现实事物的体现都是以对象的形式，所以为了方便对象的操作，就得对对象进行存储，集合就是存储对象最常用的方式。 数组和集合的不同点： l  数组虽然可以存储对象，但长度是固定的；集合长度
Java集合类笔记
To be professional
09-03 2595
集合类是Java基础技术中十分重要的内容。Java集合类封装了集合中常用数据结构和算法，它犹如哪咤的烽火轮，功能强大，而且不用亲自制造(Made in America)。 首先看下面这张表，本文即通过它展开相关内容。 Implementations Hash Table Resizable Array
集合——java学习笔记
longwanhu的博客
04-29 1538
集合，又称容器，用于存储对象（集合的元素），且长度可变，具体可以是集合类的对象，也可以是集合接口的对象（多态）。 Collection接口 collection接口的动态方法 创建对象：Collection<类型实参> col = new ArrayList<>(); //多态 引用对象的方法 col.add(元素) == 添加元素到集合，成功则返回true col.remove(元素) == 删除集合中的元素，成功则返回true col.clear; == 清空集合中的元素
java超强笔记
12-03
随着对基础知识的掌握，笔记会进一步带你探索Java集合框架，包括数组列表、链表、队列、栈、映射等数据结构，以及它们在实际问题中的应用。此外，多线程编程也是Java的一大亮点，笔记会介绍线程的创建与同步机制，如...
java集合框架笔记
03-18
List set ArraryList Map java集合框架笔记 基于Array的List，其实就是封装了Array所不具备的一些功能方便我们使用
java 集合部分笔记
05-19
【Java集合】 Java集合框架是Java编程语言中用于存储和操作对象的工具，它提供了多种数据结构，如列表、集、映射等，以适应不同的数据处理需求。集合类通常位于`java.util`包下，是Java程序员必备的知识点。 1. **...
Java基础 学习笔记 Markdownr版
06-27
2. 集合：在13集合.md中，详细讲解了Java集合框架，包括ArrayList、LinkedList、HashSet、HashMap等基本集合类的使用，以及List、Set、Map接口的特性。此外，还可能涉及泛型的概念，泛型（14泛型.md）提高了代码的...
java笔记整理(超详细) java笔记整理(超详细)
07-14
Java是一种广泛使用的高级编程语言，以其面向对象的特性、跨平台的兼容性和强大的功能而闻名。以下是关于Java的一些核心知识点： 1. **面向对象特性**： - 封装：将数据和操作数据的方法绑定在一起，形成一个独立...
java集合类笔记
lindapao的专栏
08-03 398
Java集合类是Java程序员经常使用的工具类。它里面的实现方式其实涵盖了很多的数据结果，比如：队列、栈。其中Java集合大致可以分为Set、List、Map三中体系。先主要从三个容器的使用、实现机制、使用场景做下分析总结。总结性概括：Set体系是无序的、不可重复的集合。List代表无序、可以重复。Map代表键值对。还有Queue体系结构。集合类的框架图如下：特性不同主要来源于实现的不一致性：Se
Java集合类总结笔记
weixin_34221073的博客
06-23 116
2019独角兽企业重金招聘Python工程师标准>>> ...
Java 集合类学习笔记
锦瑟年华,逐梦之人
01-19 296
数组存储弊端 在Java中存储对象可以使用数组或者集合，但使用数组存储可能会出现以下弊端： 一旦数组创建完毕，它的长度将是不可变的，如果要修改长度，只能通过创建一个新的数组，将原数组拷贝过去，这样将会增加开销。 在数组中不能直接获得存放对象的个数 Java 集合框架的基本接口 Java集合框架的基本接口图 将常用的Java 集合可分为Collecion 和 Map 两种体系 Co...
java 集合类学习笔记
Jack_Chen3的废柴人生
01-17 812
引入集合类的原因:java数组是固定长度的，数组在创建的时候就指定了长度，在一些情况下长度并不是一定的，这时就需要用集合来进行数据存储。使用集合还可以在其中放对象的引用，但不能存放基本数据类型。 集合分类:Set(集合):集合中对象不按特定的方式排序，并且没有重复对象，但它有些实现类中的对象按特定方式排序。 List(列表):集合中的对象按检索位置排序，可以有重复对象，允许按照对象在集中的索引
java集合笔记
herry57的博客
03-25 243
1、储存对象：数组和集合    数组储存对象的弊端：1.一旦创建，其大小不可变。2、数组存放的对象个数是不可知的。2、collection接口子接口：a、set：无序性、不可重复的元素（HashSet，LinkedHashSet，TreeSet）            b、list：有序性、可以重复的元素（ArrayList（首先），LinkedList，vector）3、map接口（HashMa...
JAVA集合类笔记总结
Insect_boy的博客
01-26 336
在使用集合类之间我们总是使用数组存储数据，但是数组存有一些缺点，比如数组一创建就将数组的长度限定了，没有方法适时的扩容，而且数组提供的方法很有限，很难满足对数组内数据操作的需求。所以java 提供了集合。JAVA集合类中涉及到的知识点包括如下： 1）集合类的体系架构 2）Collection的常用方法 3）迭代器 4）集合类各个类的使用的底层原理 5）比较器 6）Collections工具类 一。集合类的体系架构 java中集合主要分为两个体系，粉别是Collection和Map两个，我们常用他们的具体实现
开发多线程程序时，需要注意那些问题
最新发布
OO_SEN的博客
08-23 554
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值