集合2——List体系和Set体系

最新推荐文章于 2022-06-29 16:50:15 发布
最新推荐文章于 2022-06-29 16:50:15 发布
阅读量222 收藏
点赞数
分类专栏： java 文章标签： 链表 队列 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/coy_done/article/details/104275063
版权

文章目录

对象数组

  • 对象数组指的就是存储引用类型的数组

对象数组的使用

/*
 *对象数组(引用数组):该数组中存储的是引用类型因此我们叫它对象数组或者引用数组 
 *  引用数组中存储的是对象的地址值而不是对象 
 */
public class Demo {
	public static void main(String[] args) {
       //1.定义一个Student类型的数组
		//int[]  arr = new int[3]
		Student[] stus=new Student[2];
		
	   //2.给数组中的元素赋值
		//arr[0]=3;
		stus[0]=new Student("张三",13); 
		stus[1]=new Student("李四",24);
		
	   //3.遍历这个引用数组
	    /*
		 * for(int i=0;i<arr.length;i++){
		 *    System.out.println(arr[i])
		 * }
		 */
		for(int i=0;i<stus.length;i++){
			System.out.println(stus[i]);
		}
	}
}

内存图

在这里插入图片描述

List体系

List接口介绍

api中介绍：有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。与 set 不同，列表通常允许重复的元素。

  • List接口：

    • 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
    • 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
    • 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

  • List接口的常用子类有：

    • ArrayList集合

    • LinkedList集合

ArrayList类

ArrayList实现原理(思想)

  • ArrayList集合特点:

    底层使用是一个引用数组(Object[])

  • 扩容思想:

​ 新建一个集合的时候,底层会开辟长度为10的数组,调用add()方法会不断的往数组中添加元素当添加了10个元素,再添加第11个元素的时候,数组满了,无法存入,此时会新建一个长度为原来长度1.5倍的数组(10+10/2),接着会把原有元素拷贝到新数组中,再把第11个元素追加到末尾
在这里插入图片描述

ArrayList中特有方法

在这里插入图片描述

  • 增加元素方法

    add(Object e)：向集合末尾处，添加指定的元素

    add(int index, Object e)：向集合指定索引处，添加指定的元素，原有元素依次后移

  • 删除元素删除

remove(Object e)：将指定元素对象，从集合中删除，返回值为被删除的元素

remove(int index)：将指定索引处的元素，从集合中删除，返回值为被删除的元素

  • 替换元素方法

    set(int index, Object e)：将指定索引处的元素，替换成指定的元素，返回值为替换前的元素

  • 查询元素方法

    get(int index)：获取指定索引处的元素，并返回该元素

方法演示：

import java.util.ArrayList;
public class Demo {
    public static void main(String[] args) {
        //list中可以存储任意数据类型，必须是对象
        ArrayList list = new ArrayList();
        list.add(12);//12是Integer一个对象，自动装箱
        list.add("abc");
        list.add("def");
        list.add("abc");
        System.out.println(list);//[12, abc, def, abc]
        list.add(3,"zzz");
        System.out.println(list);//[12, abc, def, zzz, abc]
        System.out.println( list.get(1));//abc
        list.set(3,"www");
        System.out.println(list);//[12, abc, def, www, abc]
        list.remove("abc");
        System.out.println(list);//[12, abc, def, www, abc]
    }
}
ArrayList存储自定义对象
public class Person {
    private int id;
    private String name;
    //构造方法
    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }
    //getter()和setter()
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //重写toString()
    @Override
    public String toString() {
        return "Person{" + "id=" + id + ", name='" + name + '\'' + '}';
    }
}


import java.util.ArrayList;
import java.util.Iterator;
public class PersonDemo {
    public static void main(String[] args) {
        ArrayList<Person> list = new ArrayList<Person>();
        list.add(new Person(01,"张三"));
        list.add(new Person(02,"李四"));
        Iterator it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //Person{id=1, name='张三'}
        //Person{id=2, name='李四'}
    }
}
ArrayList特点

​ 查询元素较快:因为底层是数组,数组有索引

​ 增删元素较慢:

​ 添加慢,因为每次添加都需要移动大量的元素,导致浪费内存资源,效率低

  • 添加慢的原因：
    在这里插入图片描述
  • 删除慢的原因:
    在这里插入图片描述

LinkedList类

LinkedList实现思想

​ 底层使用一个链表,第一个元素记录下一个元素的地址值最终形成一条链子
在这里插入图片描述

LinkedList特有方法
/*
 * LinkedList:
 *    原理:
 *      LinkedList底层使用是链表数据结构
 * LinkedList<E>成员方法:
 *  void addFirst(E e):不断往链表的头部添加,遍历集合的时候从链头开始遍历
    void addLast(E e):不断地往链表尾部追加,遍历集合的时候从链头开始遍历
 *  
 *  E getFirst()//取链头的第一个元素,但是不会删掉链头元素
    E getLast() //取炼尾(最后一个)的元素,但是不会删掉链尾的元素
    
    E removeFirst()//取链头的第一个元素,但是会删掉链头的元素
    E removeLast() //取链尾的的元素,但是会删掉链尾的元素
  
 */
LinkedList特点

查询元素相对ArrayList较慢:因为链表都是从头开始查

增删元素相对ArrayList较快:因为链表仅仅需要改变元素中记录的地址值,而不需要移动大量元素,节省内存开销提高效率

  • LinkedList增删元素原理:
    在这里插入图片描述

栈和队列数据结构

栈:特点:元素后进先出(先进后出) :手枪弹夹

队列:特点:元素先进先出(后进后出):银行叫号

Set体系

学习Collection接口时，记得Collection中可以存放重复元素，也可以不存放重复元素，那么我们知道List中是可以存放重复元素的。那么不重复元素给哪里存放呢？那就是Set接口，它里面的集合，所存储的元素就是不重复的。

Set接口介绍

查阅HashSet集合的API介绍：此类实现Set接口，由哈希表支持（实际上是一个 HashMap集合）。HashSet集合不能保证的迭代顺序与元素存储顺序相同。

即特点为：无序，不重复

HashSet类

HashSet基本使用

HashSet依然具有集合通用的特点:利用add添加元素,使用迭代器遍历,使用增强for遍历

方法列表：

	add()		remove()		contains()		clear()		size()

  • Set无序，所有没有下标的获取方式。因此没有get(i)

  • Set中不能查看一个元素

/*
 * Set接口:没有索引,存储的元素唯一,存取顺序不一定一致
 *   HashSet:没有索引,保证元素唯一,存的顺序和取的顺序不一定一致
 *   成员方法:
 *     Iterator<E> iterator() 
 */

import java.util.HashSet;
import java.util.Iterator;
public class Demo {
    public static void main(String[] args) {
        HashSet<String> hs=new HashSet<String>();
        hs.add("aa");
        hs.add("bb");
        hs.add("cc");
        //1.获取迭代器对象
        Iterator<String> it=hs.iterator();
        //2.循环遍历
        //迭代器
        while(it.hasNext()){
            String str=it.next();
            System.out.println(str);
        }
        /*增强for
        for(String str : hs){
            System.out.println(str);
        }
        */
    }
}

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
//Set集合过滤字符串
public class Demo {
    //Scanner输入字符串去重
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入字符串：");
        String str = input.nextLine();
        //1.String-->Char[]
        char[] cs = str.toCharArray();
        //2.Set集合
        Set<Character> set = new HashSet<>();
        //3.将每个字符放在Set中
        for (int i = 0 ; i < cs.length ; i++){
            set.add(cs[i]);//add()自带过滤重复
        }
        System.out.println(set);
    }
}

add()判断对象是否重复，依赖contains()

contains()底层依赖equals(),重写equals()就能在Set集合中解决对象重复的问题。

哈希算法
  • 哈希算法相对于普通查找更快
    在这里插入图片描述
  • 哈希算法保证唯一原理
    在这里插入图片描述
HashSet存入字符串保证唯一原理

存入HashSet的字符串依赖两个方法，一个是hashCode()方法，一个是equals()方法,注意这两个方法出自Object类,但是String都把这两个方法重写了,String的类的hashCode()方法不再像Object类的hashCode()方法返回内存地址值,而是根据一定的算法计算字符串中字符的ASCII码值,String类的equals()方法就是比较两个字符串的内容

import java.util.HashSet;
/*
 * HashSet唯一原理
 *   先调用hashCode()方法比较元素的哈希值
 *   如果添加的元素哈希值与集合中的元素的哈希值不同,直接存入
 *   如果添加的元素哈希值与集合中的元素的哈希值相同
 *      调用equals()方法比较两个元素的内容
 *         equals()返回true,说明两个元素内容相同,认为重复,不存
 *         equals()返回false,说明两个元素内容不同,存
 *   Object类中原始的hashCode()返回的就是内存地址值
 */
public class Demo {
    public static void main(String[] args){
        HashSet<String> hs=new HashSet<String>();
        hs.add("ab");//当存入第一个ab时候直接存入
        hs.add("ab");//当存入第二ab的时候,先调用hashCode()方法获取两个元素哈希值,比较发现相同
        //在调用equals方法比较,"ab".euqlas("ab")//true,第二个ab就不存

        hs.add("bc");//当存入bc的时候,先调用hashCode()方法获取两个元素哈希值
        //比较发现不同,直接存入    
        System.out.println(hs);//[ab, bc]
        System.out.println("ab".hashCode());//3105
        System.out.println("bc".hashCode());//3137
    }
}
HashSet存取自定义对象保证唯一原理

当我们存储自定义对象中出现同名同年龄的,利用HashSet不能去重:

因为Person利用的是从Object类中继承的hashCode方法,获取的是元素的地址值比较

而每个Person都是新new的Person,地址值均不同

public class Person /*extends Object*/ {
    private String name;
    private int age;

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

}


import java.util.HashSet;
/*
 * 利用HashSet存储自定义对象
 */
public class PersonDemo {
    public static void main(String[] args) {
        //1.创建HashSet集合
        HashSet<Person> hs=new HashSet<Person>();

        //2.创建3个Person对象
        /*Person p=new Person("张三",12);
         *hs.add(p);
         */
        hs.add(new Person("张三",12));//匿名对象
        hs.add(new Person("张三",12));//调用hashCode()方法获取哈希值(内存地址值),去比较
        //第二个Person对象的哈希值和第一个Person的哈希值不同
        //第二个Person直接存入
        hs.add(new Person("王五",16));

        //3.遍历HashSet集合
        for(Person p : hs){
            System.out.println(p.getName()+" "+p.getAge());
        }
        //张三 12
        //张三 12
        //王五 16
    }
}

我们尝试改写(重写)原有的hashCode与equals方法保证同名同年龄的人被过滤掉

public class Person /*extends Object*/ {
    private String name;
    private int age;

    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;
    }
    /*我们在重写hashCode()一般用上这个类的所有属性来产生哈希值*/
	/*@Override
	public int hashCode() {
		 //return 10;
		return name.hashCode() + age;
	}*/
    /*
     *return 10,让所有元素都产生了相同哈希值,所有元素都得去调用
     *equals()比较
     * 对于new Person("张三", 12)还有new Person("王五", 16)
     *  两者的姓名和年龄都不同,没必要再去调用equals比较
     */

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }


    /*
     * euqual方法的重写与之前的相同
     *  如果两个人的姓名和年龄均相同,认为是同一个人,返回true
     *  如果两个人的姓名和年龄至少有一个不同返回false
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) 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;
    }
}

import java.util.HashSet;
public class PersonDemo {
    public static void main(String[] args) {
        // 1.创建HashSet集合
        HashSet<Person> hs = new HashSet<Person>();

        // 2.创建3个Person对象
        Person p1=new Person("张三", 12);
        Person p2=new Person("张三", 12);
        Person p3=new Person("王五", 16);
        hs.add(p1);//p1直接存入
        hs.add(p2);//存入p2,需要调用hashCode()方法获取p1,p2的哈希值
        //哈希值相同,需要再去比较equals(),返回true,认为相同元素,不存
        hs.add(p3);//存入p3,需要调用hashCode()方法获取p3,p1的哈希值
        //不同,直接将p3存入

        System.out.println(p1.hashCode());//776222
        System.out.println(p2.hashCode());// 776222
        System.out.println(p3.hashCode());// 938522

        // 3.遍历HashSet集合
        for (Person p : hs) {
            System.out.println(p.getName() + " " + p.getAge());
        }
        //王五 16
        //张三 12
    }
}
苦岩
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
集合:List和Set
kekekeliang的博客
09-18 376
集合、List Set 、并发修改异常
Collection体系以及List和Set体系
最新发布
QingQingwuyan的博客
01-06 238
本篇对Collection体系以及其下的List和Set体系进行的详解
Java Set系列集合
m0_47320958的博客
12-05 794
Set系列集合特点： 无序:存取顺序不一致 不重复:可以去除重复 无索引:没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引来获取元素。 Set集合实现类特点： Hashset :无序、不重复、无索引。 LinkedHashSet:有序、不重复、无索引。 TreeSet:排序、不重复、无索引。 Set集合的功能基本上与Collection的API一致。 import java.util.HashSet; import java.util.LinkedHashSet; import
Set集合详细讲解
m0_65725031的博客
06-29 2123
目录一.Set集合二.HashSet集合 foreach循环遍历迭代器遍历数组 三.TreeSet集合今天的学习就到这里啦。
java中list集合转set集合_java集合中：set与list相互转换
weixin_42363231的博客
02-24 2万+
1、set转成list：(两种方法)Setset = new HashSet();set.add("c");set.add("d");set.add("a");set.add("a");//方法一：Listlist = new ArrayList(set);for(Strings : list) {System.out.println(s);}System.out.println();//方法二：...
Java中的set集合
weixin_41769596的博客
03-15 314
1 Set 1.1 特点 不允许出现重复的元素 无序的集合 提供了equals(Object o)和hashCode()，供其子类重写，以实现对集合中插入重复元素的处理 1.2 实现类 HashSet类 TreeSet类 1.3 方法 add( ) 向集合中添加元素 clear( ) 去掉集合中所有的元素 contains( ) 判断集合中是否包含某一个元素 isEmpty( ) 判断集合是否为空 iterator( ) 主要用于递归集合，返回一个I
JavaSE基础自学------集合框架--Set体系
真正的大师,永远都怀着一颗学徒的心----易大师
02-15 225
Set体系(Hash)
Java Set集合详解
qq_51751452的博客
11-22 2万+
一：set集合框架体系图 二：set集合介绍 Set接口继承了Collection接口,含有许多常用的方法。 int size();返回集合的长度 boolean isEmpty();判断集合是否为空 boolean contains(Object o);是否包含某个值 boolean add(E e);添加元素 boolean remove(Object o);删除元素 Set接口的存储特点是无序不可重复，可以存放唯一一个null值，Set的常用实现类有HashSet，TreeSet。 Set集合的
Java集合中List,Set以及Map等集合体系详解(史上最全)
热门推荐
君羊
06-12 33万+
概述: List Set Map都是接口，前两个继承至Collection接口，Map为独立接口 Set下有HashSet，LinkedHashSet，TreeSet List下有ArrayList，Vector，LinkedList Map下有Hashtable，LinkedHashMap，HashMap，TreeMap 还有Collection接口下还有个Queue接口，有Priority...
java 之集合体系（三 set）
z_x_Qiang的博客
01-28 691
1.set集合 set中的方法和collection中的方法是一样的，没有任何特有方法；主要学习set的子类：HashSet，TreeSet 2.HashSet 特点：无索引，元素不重复（唯一），无序（存取顺序不一致） public static void demo1() { HashSet hs = new HashSet<>(); //创建HashSet对象
java基础6：List，Set体系详解，哈希表原理，及案例
qq_3775566111的博客
11-15 257
第1章 List接口 我们掌握了Collection接口的使用后，再来看看Collection接口中的子类，他们都具备那些特性呢？ 接下来，我们一起学习Collection中的常用几个子类（List集合、Set集合）。 1.1 List接口介绍 查阅API，看List的介绍。有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元
Java进阶—— 集合体系详解之Set体系无序不重复集合
最美不过，心中有梦，身旁有你！
09-23 1万+
前一篇博文Java 集合体系详解——List体系有序集合总结了下List体系集合的用法，这一篇主要总结Set体系集合的相关知识点，Set集合体系存储特点是元素是无序的（存入和取出的顺序不一定一致的），元素不可以重复。和List集合一样拥有Collection接口的所有方法，当然也同样可以使用iterator()获得迭代器来进行遍历。Set集合体系之HashSet和TreeSet集合。
《STL》— set集合容器
69小石头的博客
08-01 465
set集合容器 set集合容器实现了红黑树（Red-Black Tree）的平衡二叉检索树的的数据结构，在插入元素时，它会自动调整二叉树的排列，把该元素放到适当的位置，以确保每个子树根节点的键值大于左子树所有节点的键值，而小于右子树所有节点的键值；另外，还得确保根节点的左子树的高度与...
Java Set集合的详解
重心开始，重新开始
07-26 21万+
一，Set Set:注重独一无二的性质,该体系集合可以知道某物是否已近存在于集合中,不会存储重复的元素 用于存储无序(存入和取出的顺序不一定相同)元素，值不能重复。 对象的相等性    引用到堆上同一个对象的两个引用是相等的。如果对两个引用调用hashCode方法，会得到相同的结果，如果对象所属的类没有覆盖Object的hashCode方法的话，hashCode会返回每个对象特有的序号（j
javase之Set集合体系
qq_43257103的博客
03-07 143
package zhang.javase.TestSet; import java.util.Comparator; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedHashSet; import java.util.Set; import java.util.TreeSet; import o...
python set大小_Python 入门系列 —— 19.Set 介绍
weixin_36009977的博客
02-19 3842
Setset 可用于在一个变量中存储多个值，set是 python 中内建的四个集合之一，其他的三个依次是：List,Tuple, Dictionary,它们有着自己的场景和用途。set 集合是无序无索引的集合，常用 {} 表示，比如下面的例子：thisset = {"apple", "banana", "cherry"}print(thisset)PS E:\dream\markdown\pyt...
Set集合
菜鸟爱学习的博客
12-11 609
Set集合是无序、不重复和可扩展的Collection衍生类，它存放的是具有相同特性的一组对象。在实现方式上，HashSet、TreeSet都依赖于Map集合，而线程安全上SynchronizedSet、SynchronizedSortedSet都锁定内部对象mutex，在结构修改上保证操作的原子性，CopyOnWriteArraySet保证每次操作都是整个容器进行拷贝，避免fail-fast异常。
List 集合转成Set 集合..
zhou363667565的专栏
05-18 8490
★ 数组转Collection 使用Apache Jakarta Commons Collections： import org.apache.commons.collections.CollectionUtils;       String[] strArray = {"aaa", "bbb", "ccc"};    List strList = new ...
集合默认容量大小
weixin_41040866的博客
11-07 1022
ArrayList、Vector、HashMap、HashTable、HashSet的默认初始容量、加载因子、扩容增量 这里要讨论这些常用的默认初始容量和扩容的原因是： 当底层实现涉及到扩容时，容器或重新分配一段更大的连续内存（如果是离散分配则不需要重新分配，离散分配都是插入新元素时动态分配内存），要将容器原来的数据全部复制到新的内存上，这无疑使效率大大降低。 加载因子的系数小于等于1，意指 即...
Java编程：深入理解List和Set集合
这篇资料主要涵盖了Java编程语言中的两种重要集合类型——List和Set，以及相关的Collections工具类。List和Set都是Java集合框架的一部分，它们提供了存储和管理对象的方式，但各自有不同的特点和使用场景。 List是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值