java集合

已于 2022-04-01 13:28:46 修改
阅读量440 收藏
点赞数
文章标签： java
于 2022-03-30 22:08:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39238154/article/details/123858580
版权

集合

  • 什么是集合

    概念

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

    和数组的区别

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

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

Collection

  • Collection体系

  • collection父接口

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

    • 创建集合 和常用方法 遍历

      package Collection;
​
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
​
public class Demo01 {
    public static void main(String[] args){
        //创建集合
        Collection collection=new ArrayList();
        //添加元素
        collection.add("苹果");
        collection.add("西瓜");
        collection.add("榴莲");
        System.out.println("元素个数："+collection.size());
        collection.remove("榴莲"); //删除元素
//        collection.clear();//清空元素
        System.out.println(collection);
//        ===========================================
        //遍历元素
        for(Object object:collection){
            System.out.print(object);
        }
        System.out.println();
        //使用迭代器
        //hasNext();判断有木有下一个元素 有返回true
        //next();获取下一个元素
        //remove();删除当前元素
        System.out.println("===========迭代器==============");
        Iterator it = collection.iterator();
        while (it.hasNext()){
            System.out.print(it.next());
            it.remove();//删除
        }
        //判断
        System.out.println("======判断=========");
        System.out.println(collection.contains("西瓜")); //判断是否存在该元素 如果存在返回true
        System.out.println(collection.isEmpty()); //判断是否为空
        System.out.println(collection.size());// 结果为0
    }
}
​

  • 操作实体类

    • 新建一个student类

    package Collection;
​
import jdk.nashorn.internal.runtime.regexp.joni.ast.StringNode;
​
public class Student {
    private String name;
    private int 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;
    }
​
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public Student() {
    }
}
​
    package Collection;
​
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
​
public class Demo02 {
    public static void main(String[] args) {
        Collection<Student> collection = new ArrayList();
        Student s1 = new Student("zwf", 120);
        Student s2 = new Student("zwf", 120);
        Student s3 = new Student("小明", 120);
        collection.add(s1);
        collection.add(s2);
        collection.add(s3);
        System.out.println(collection.toString()); //前面实体类忘记加toString方法了 输出是地址值
        //删除
        collection.remove(s1);
        //遍历
        for (Object o:collection) {
            System.out.println(o.toString());
        }
        //使用迭代器
        Iterator<Student> iterator = collection.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next().toString());
        }
    }
}
​

List

  • 特点：有序，有下标，元素可以重复

  • 看代码不多说

package List;
​
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
​
//特点：有序，有下标，元素可以重复
public class demo01 {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add("苹果");
        list.add("香蕉");
        list.add("梨子");
        System.out.println("元素个数:"+list.size());
        //list.remove(0);
        //list.remove("苹果");
        System.out.println(list.toString());
        //遍历
        //1
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //2
        for(Object object:list){
            System.out.println(object);
        }
        //3使用迭代器
        Iterator it=list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //3.1使用列表迭代器,可以向前或向后遍历，添加，删除，修改
        ListIterator it1 = list.listIterator();
        System.out.println("----------从前往后-----------");
        while (it1.hasNext()){
            System.out.println(it1.nextIndex()+":"+it1.next());
        }
        System.out.println("----------从后往前-----------");
        while (it1.hasPrevious()){//这个方法就是把List数组的指针先指向末尾
            System.out.println(it1.previousIndex()+":"+it1.previous());
        }
        //判断
        System.out.println(list.contains("苹果"));//判断是否有这个元素
        System.out.println(list.isEmpty());//是否为空
        //获取位置（下标）
        System.out.println(list.indexOf("苹果"));
    }
​
}
​

关于使用List集合的几个小细节

package List;
​
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
​
public class demo02 {
    public static void main(String[] args) {
        List list =new ArrayList();
        //添加数字数据(自动装箱)  就是它会把这个数据包装成Integer引用类型
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(250);
        //List集合的subList方法： 放回子集合，含头不含尾  就是【1，2，3】  list.subList(0,2)得到集合 list[1,2]
        List list1 = list.subList(0, 3);
        System.out.println(list1.toString());
        /*
         *ListIterator逆序遍历时，必须先进行正序遍历，为了将下标(指针)放到元素n后面，从而可以进行逆序遍历
         * 或者就在调用list的listIterator方法的时候将list.size()方法作为参数放入
         *  例：ListIterator listIterator = list.listIterator(  list.size()   );
         * */
        ListIterator listIterator = list.listIterator(list.size());
        System.out.println(listIterator.hasNext());//结果为 false
        System.out.println(listIterator.hasPrevious());//结果为true  如果参数不加list.size 它俩结果相反
        while (listIterator.hasPrevious()){
            System.out.println("下标"+listIterator.previousIndex()+"值:"+listIterator.previous());
        }
        //删除  可以通过下标 或者就是先用integer包装后删除
        list.remove(new Integer(20));
        list.remove(0);
        list.remove((Object)20);//强转为Object也可以
​
    }
}
​

ArrayList

package Set;
​
import Collection.Student;
​
import java.util.HashSet;
import java.util.Iterator;
​
/**
 * HashSet集合的使用
 * 存储结构：哈希表(数组+链表+红黑树)
 * 存储过程
 * (1)根据hashcode计算存储位置，如果此位置为空，则直接存储，如果不为空执行第二步
 * (2)再执行equals方法。如果equals方法为true，则认为是重复，否则，形成链表
 */
public class demo02 {
    public static void main(String[] args) {
        HashSet<Object> set = new HashSet<>();
        Student s1=new Student("小明",1);
        Student s2=new Student("小红",2);
        Student s3=new Student("小花",3);
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(new Student("小明",1));//这里要想它不加进来就需要重写 hashCode，equals
        System.out.println("元素个数"+set.size());
        Iterator<Object> iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next().toString());
        }
    }
}
​

package Map;
​
import java.util.ArrayList;
​
import java.util.Collections;
import java.util.List;
​
public class demo03 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(20);
        list.add(4);
        list.add(54);
        list.add(34);
        list.add(6);
        list.add(60);
        //sort排序
        System.out.println("排序之前"+list.toString());
        Collections.sort(list);
        System.out.println("排序之后"+list.toString());//从小到大排序
        //binarySrarch 二分查找
        int i=Collections.binarySearch(list,4);
        System.out.println(i);//打印下标
        //copy复制
        List<Integer> list1 = new ArrayList<>();
        for (i=0;i<list.size();i++){
            list1.add(0);
        }//因为复制的要求是原数据和要复制的数据长度要相同
        Collections.copy(list1,list);
        System.out.println(list1);
        //反转
        Collections.reverse(list);
        System.out.println("反转之后"+list.toString());
    }
}

TreeSet

 

Map

 

package Map;
​
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
​
/**
 * Map接口的使用
 * 特点： （1）键不能重复，值可以 2，无序
 */
public class demo01 {
    public static void main(String[] args) {
        //创建Map集合
        Map<String,String> map=new HashMap<>();
        //添加元素
        map.put("cn","中国");
        map.put("uk","英国");
        map.put("usa","美国");
        map.put("cn","zhongguo");//如果键重复会覆盖前面的值
        System.out.println("元素个数"+map.size());
        System.out.println(map.toString());
        //删除
//        map.remove("usa");
        //遍历key和值
        Set<String> s = map.keySet();
        for (String key:s) {
            System.out.println(key+"------"+map.get(key));
        }
        //使用entrySet()方法
        System.out.println("--------entrySet方法遍历-------");
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String,String> entry:entries){
            System.out.println(entry.getKey()+"-----------"+entry.getValue());
        }
    }
}
​

HashMap

都差不多不演示了

package Map;
​
import java.util.HashMap;
​
public class demo02 {
    public static void main(String[] args) {
        HashMap<Student, String> map = new HashMap<>();
        Student s1=new Student("孙悟空",100);
        Student s2=new Student("猪扒就",102);
        Student s3=new Student("萨赫尚",103);
        map.put(s1,"北京");
        map.put(s2,"杭州");
        map.put(s3,"上海");
        map.put(new Student("萨赫尚",103),"上海1");//重写hashcode和equals就好然后就是覆盖前面的键
        System.out.println(map);
        System.out.println(map.size());
    }
}
​

Collections工具类

  • Student实体类

    package ArrayList;
​
import java.util.Objects;
​
public class Student {
    private String name;
    private int 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;
    }
​
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public Student() {
    }
​
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
​
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }
​
}
​

  • 测试

    package ArrayList;
​
import java.util.ArrayList;
​
/*
* ArrayList:
* 存储结构：数组 查找遍历快，增删改慢
* */
public class demo01 {
    public static void main(String[] args) {
        ArrayList<Object> list = new ArrayList<>();
        Student s1=new Student("小明",1);
        Student s2=  new Student("小红",2);
        Student s3= new Student("小花",3);
        list.add(s1);
        list.add(s2);
        list.add(s3);
        //删除
        /*如果要删除小明这个数据，正常情况这样删除是无法删除原来的小明数据因为该方法是通过equals(this==obj)比较的是地址，
        所以这里我们要重写equals才能实现
        */
       list.remove(new Student("小明",1));
        System.out.println(list.toString());
        System.out.println(list.size());
        //循环我就不打了 和上面差不多
        //查找
        System.out.println(list.indexOf(new Student("小红",2))); //查找该元素下标 如果不存在返回-1
    }
}
​

    LinkedList

    package LinkedList;
​
​
​
import Collection.Student;
​
import java.util.LinkedList;
import java.util.ListIterator;
​
/**
 * LinkedList的使用
 * 存储结构:双向链表
 */
public class demo01 {
    public static void main(String[] args) {
        LinkedList linkedList=new LinkedList();
        //添加元素
        Student s1=new Student("小明",1);
        Student s2=new Student("小红",2);
        Student s3=new Student("小花",31);
        linkedList.add(s1);
        linkedList.add(s2);
        linkedList.add(s3);
        System.out.println(linkedList.size());
        System.out.println(linkedList.toString());
        //删除
        linkedList.remove(0);// linkedList.remove(s1); 等价
        //遍历
        ListIterator listIterator = linkedList.listIterator(linkedList.size());
        while (listIterator.hasPrevious()){
            System.out.println(listIterator.nextIndex()+":值"+listIterator.previous());
        }
​
    }
}
​

    Set

    特点

  • 无序，无下标，元素不可重复

  • package Set;
​
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<>();
        set.add("小明");
        set.add("小红");
        set.add("小花");
        set.add("小明");//这里会添加不进去，因为set是不可重复的
        System.out.println(set.size()); //结果为3
        System.out.println(set.toString());
        //判断
        System.out.println(set.contains("小明"));//true
        System.out.println(set.isEmpty());//false
        //遍历
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.print(iterator.next());
        }
    }
}
​

    HashSet

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

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

  • 重写hashCode和equals

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }
​
    @Override
    public int hashCode() {
​
        return this.name.hashCode()+this.age;
    }

package Map;

import java.util.ArrayList;

import java.util.Collections;
import java.util.List;

public class demo03 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(20);
        list.add(4);
        list.add(54);
        list.add(34);
        list.add(6);
        list.add(60);
        //sort排序
        System.out.println("排序之前"+list.toString());
        Collections.sort(list);
        System.out.println("排序之后"+list.toString());//从小到大排序
        //binarySrarch 二分查找
        int i=Collections.binarySearch(list,4);
        System.out.println(i);//打印下标
        //copy复制
        List<Integer> list1 = new ArrayList<>();
        for (i=0;i<list.size();i++){
            list1.add(0);
        }//因为复制的要求是原数据和要复制的数据长度要相同
        Collections.copy(list1,list);
        System.out.println(list1);
        //反转
        Collections.reverse(list);
        System.out.println("反转之后"+list.toString());
    }
}

故及
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java集合相减_Java集合的运算之减法A-B
weixin_29580355的博客
02-16 2991
import com.sun.media.sound.SoftSynthesizer;import java.util.*;public class a123 {public static void main(String args[]) {int m, n;Scanner in = new Scanner(System.in);while ((m = in.nextInt()) != 0 | (...
Java集合
06-13
Java的集合类是一种特别有用的工具类，它可以用于存储数量不等的多个对象，并可以实现常用数据结构，如栈，队列等，除此之外，Java集合还可用于保存具有映射关系的关联数组。 Java的集合大致上可分为：Set,List和...
Java集合底层原理
小凯的博客
03-04 2508
Java集合框架的体系结构、集合架构中的类、算法、底层原理
Java集合特点
m0_68206534的博客
03-26 4226
1、基本语法 这包括static、final、rtransient等关键字的作用，foreach循环的原理等等。 2、集合 基本上就是List、Map、Set，问的是各种实现类的底层原理，实现类的优缺点 List集合：有序集合，用户可以精确控制列表中每个元素的插入位置。用户也可以通过整数索引访问元素，并搜索列表中的元素。与Set集合不同，列表通常允许重复元素。 ArrayList的底层数据结构是数组 特点： 索引查询速度最快；长度可以自动动态变化 添加和删除元素效率低；按照内容查询需要逐个比
java集合（超详细）
热门推荐
zdl66的博客
08-12 5万+
所有的集合类和集合接口都在java.util包下。 在内存中申请一块空间用来存储数据，在Java中集合就是替换掉定长的数组的一种引用数据类型。
Java集合去重
qq_41053971的博客
04-21 7248
在日常工作中，我们时常会遇到需要对数据进行遍历去重的操作，笔者便将自己所熟知的几种方法分享给大家。 首先模拟一个实体类，并创建一个main方法调用。 public static void main(String[] args) { List<User> list = new ArrayList(4); list.add(new User("张三","杭州")); list.add(new User("李四","上海")); .
Java 集合分页
暗武逢天的博客
03-08 5323
java实现集合分页
Java集合详解
qq_45687780的博客
04-25 2万+
基于java从入门到项目实战材料学习+个人理解总结！
Java集合框架的全面分析和性能增强
沉淀、分享、成长，让自己和他人都能有所收获！
07-28 8716
Java集合框架在Java编程中起着至关重要的作用。它提供了一系列的数据结构和算法，用于存储、操作和访问数据。然而，为了充分利用集合框架的强大功能，开发人员需要深入了解其内部机制，并注意性能优化。本博客将深度解析Java集合框架的核心组件，包括List、Set、Map等接口及其实现类，同时提供优化技巧和示例，助力新手更好地理解和学习。
java 集合
04-07
NULL 博文链接：https://wuzq1223.iteye.com/blog/1564290
Java集合框架
12-22
Java集合框架 集合：集合就是一个容器，可以存储很多东西，可以添加，可以删除，可以修改。 Collection接口 Collection接口式Java集合的根接口，是所有集合的父接口。该接口里面提供了很多操作集合的抽象方法。 ...
实验05 Java集合.doc
06-27
"hobby"－"爱学Java" 3）对集合进行遍历，分别打印集合中的每个元素的键与值； 4）打印集合的大小，然后删除集合中的键为age的元素，并显示删除元素的内容，并再次打印集合的大小。 四、思考题 1、集合中的List、...
【Java】Java集合框架思维导图。
04-13
xmind格式的Java集合框架学习导图，包括Collection接口/Map接口以及具体实现类。 同样包含大厂面试题，也在导图中有所体现。 能学到什么： 更加成体系的知识框架，更加全面的、系统的知识。 思维导图： 思维导图具有...
java集合图
05-15
java集合思维导图，mindmaster打开，非常好用的思维导图画图工具
java集合java集合java集合java集合java集合
08-02
java集合
Java 集合概览(小结)
08-27
Java 集合概览小结 Java 集合概览是 Java 语言中的一种重要组件，提供了多种类和接口来帮助我们存储和管理对象集合。Java Collection API 中的集合类主要位于 java.util 包中，同时也有一些与并发相关的集合类位于 ...
java集合框架面试题
11-08
内含大量java集合框架方面常被面试官问到的经典面试题。
java集合方法大全
最新发布
06-01
Java集合是Java编程中非常重要的一部分，常用于数据的存储和操作。Java提供了多种集合类和接口，包括List、Set、Map等等，每个集合类都提供了许多方法，可以对集合进行增删改查等操作。 下面是Java集合中常用的一些...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值