Java学习List接口Set接口

Posted 低调的小孩儿

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java学习List接口Set接口相关的知识,希望对你有一定的参考价值。

Collection中常用的两大子类(List集合、Set集合)

List接口

1、它是一个元素存取有序的集合。这里的有序不是说集合按照升序降序进行存储,而是说元素怎么存进去,怎么取出来的

2、它是一个带有索引的集合,通过索引就可以精确的操作集合中的元素(与数组的索引是一个道理)。

3、 集合中可以有重复的元素,通过元素的equals方法,来比较是否为重复的元素。

List接口的常用子类有:

1、ArrayList集合

2、LinkedList集合

List中常用的方法:

package com.oracle.demo1;

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

public class ListDemo {

	public static void main(String[] args) {
		add();
		remove();
		set();
		get();
        edit();
	}

	/*
	 * void add(int index,E element) 在指定位置添加元素
	 * java.lang.IndexOutOfBoundsException 集合的越界异常
	 * java.lang.ArrayIndexOutOfBoundsException 数组的越界异常
	 * java.lang.StringIndexOutOfBoundsException 字符串的越界异常
	 */
	public static void add() {
		List<String> list = new ArrayList<String>();
		list.add("asd");
		list.add("123");
		list.add("zxc");
		list.add(0, "xxx");
		System.out.println(list);
	}

	/*
	 * E remove(int index) 
	 * 1、删除指定位置上的元素 
	 * 2、返回被删除的元素的值
	 */
	public static void remove() {
		List<String> list = new ArrayList<String>();
		list.add("asd");
		list.add("123");
		list.add("zxc");
		String element = list.remove(0);
		System.out.println(element);
		System.out.println(list);
	}

	/*
	 * E set(int index,E element) 
	 * 1、替换指定位置上的值
	 * 2、获取替换之前的值
	 */
	public static void set() {
		List<String> list = new ArrayList<String>();
		list.add("asd");
		list.add("123");
		list.add("zxc");
		System.out.println(list);
		String e = list.set(1, "李四");
		System.out.println(e);
	}
	/*
	 * E get(int index)
	 * 获取指定索引上的元素值
	 * */
	public static void get(){
		List<String> list = new ArrayList<String>();
		list.add("asd");
		list.add("123");
		list.add("zxc");
		System.out.println(list);
		System.out.println(list.get(0));
		for(int i=0;i<list.size();i++){
           System.out.println(list.get(i));
		}
		System.out.println("=================");
		for(String e:list){
			System.out.println(e);
		}
		System.out.println("=================");
		Iterator<String> it=list.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}
	/*
	 * Iterator并发修改异常
	 * java.util.ConcurrentModificationException
	 * 在遍历的过程中不能做修改长度的操作,不然会发生并发修改异常
	 * */
	public static void edit(){
		List<String> list = new ArrayList<String>();
		list.add("asd");
		list.add("123");
		list.add("zxc");
		Iterator<String> it=list.iterator();
		while(it.hasNext()){
			String str=it.next();
			if(str.equals("123")){
				int i=list.indexOf("123");
				list.add(i, "lisi");
			}
			System.out.println(list);
		}
	}
//并发修改异常解决办法:在迭代时,不要使用集合的方法操作元素。

        //那么想要在迭代时对元素操作咋办?

        //通过ListIterator迭代器操作元素是可以的,ListIterator的出现,解决了使用Iterator迭代过程中可能会发生的错误情况。

}

List集合存储的数据结构

数据存储的常用结构有:堆栈、队列、数组、链表

堆栈  采用该结构的集合,对元素的存取有如下的特点:

         先进后出(即,存进去的元素,要在后它后面的元素依次取出后,才能取出该元素)。例如,子弹压进弹夹,先压进去的子弹在下面,后压进去的子弹在上面,当开枪时,先          弹出上面的子弹,然后才能弹出下面的子弹。

         栈的入口、出口的都是栈的顶端位置

         压栈:就是存元素。即,把元素存储到栈的顶端位置,栈中已有元素依次向栈底方向移动一个位置。

         弹栈:就是取元素。即,把栈的顶端位置元素取出,栈中已有元素依次向栈顶方向移动一个位置。

        

队列 采用该结构的集合,对元素的存取有如下的特点:

        先进先出(即,存进去的元素,要在后它前面的元素依次取出后,才能取出该元素)。例如,安检。排成一列,每个人依次检查,只有前面的人全部检查完毕后,才能排到当           前的人进行检查。

        队列的入口、出口各占一侧。例如,下图中的左侧为入口,右侧为出口。

       

数组 采用该结构的集合,对元素的存取有如下的特点:

         查找元素快:通过索引,可以快速访问指定位置的元素

         增删元素慢

                            指定索引位置增加元素:需要创建一个新数组,将指定新元素存储在指定索引位置,再把原数组元素根据索引,复制到新数组对应索引的位置。如下图

                            指定索引位置删除元素:需要创建一个新数组,把原数组元素根据索引,复制到新数组对应索引的位置,原数组中指定索引位置元素不复制到新数组中。如下图

       

链表 采用该结构的集合,对元素的存取有如下的特点:

         多个节点之间,通过地址进行连接。例如,多个人手拉手,每个人使用自己的右手拉住下个人的左手,依次类推,这样多个人就连在一起了。

        查找元素慢:想查找某个元素,需要通过连接的节点,依次向后查找指定元素

        增删元素快

                          增加元素:操作如左图,只需要修改连接下个元素的地址即可。

                          删除元素:操作如右图,只需要修改连接下个元素的地址即可。

        

ArrayList集合数据存储的结构是数组结构元素增删慢,查找快,所以日常开发中的查询数据,遍历数据,ArrayList集合是最常用的

LinkedList集合数据存储的结构是链表结构,元素增删快,查找慢,在实际开发中对一个集合的增删经常涉及到首尾操作,在LinkedList集合中提供了一下方法,如下

package com.oracle.demo2;

import java.util.LinkedList;

public class LinkedListDemo {
	public static void main(String[] args) {
		add();
		get();
		remove();
	}

	/*
	 * void addFirst(E e) 将指定元素插入到此列表的开头 void addLast(E e) 将指定元素插入到此列表的结尾
	 */
	public static void add() {
		LinkedList<String> list = new LinkedList<String>();
		list.addLast("好好学习");
		list.add("HelloWorld");
		list.addFirst("你好");
		System.out.println(list);
	}

	/*
	 * E getFirst() 返回此列表的第一个元素 
	 * E getLast() 返回此列表的最后一个元素
	 * java.util.NoSuchElementException
	 * 当集合中没有元素时再获取元素会报异常
	 * boolean isEmpty()  如果列表中不包含元素,返回true
	 */
	public static void get() {
		LinkedList<String> list = new LinkedList<String>();
		list.addLast("好好学习");
		list.add("HelloWorld");
		list.addFirst("你好");
		list.clear();
		if(!list.isEmpty()){
			String s = list.getFirst();
			String f = list.getLast();
			System.out.println(s + "=========" + f);
		}else{
			System.out.println("NoSuchElementException");
		}	
	}
	/*
	 * E removeFirst()  移除并返回列表中的第一个元素
	 * E removeLast()  移除并返回列表中的最后一个元素
	 * */
	public static void remove(){
		LinkedList<String> list = new LinkedList<String>();
		list.addLast("好好学习");
		list.add("HelloWorld");
		list.addFirst("你好");
		System.out.println(list.removeFirst());
		System.out.println(list.removeLast());
		System.out.println(list);
	}
}

Vector集合

Vector集合数据存储的结构是数组结构,为JDK中最早提供的集合。Vector中提供了一个独特的取出方式,就是枚举Enumeration,它其实就是早期的迭代器。此接口Enumeration的功能与 Iterator 接口的功能是类似的。Vector集合已被ArrayList替代。枚举Enumeration已被迭代器Iterator替代。

Set接口

set接口的特点:和List接口的特点相反,无序、可重复、无索引

package com.oracle.demo3;

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

public class SetDemo {
	public static void main(String[] args) {
		Set<String> set = new HashSet<String>();
		set.add("123");
		set.add("asd");
		set.add("w34ww");
		set.add("dvef");
		set.add("dvef");
		// set中没有索引,无序
		// 1、用Iterator遍历
		Iterator<String> it = set.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
		System.out.println("===============");
		// 2、增强for循环
		for (String str : set) {
			System.out.println(str);
		}
	}
}

执行结果

HashSet集合

HashSet 实现Set接口,由哈希表支持(实际上是一个HashMap集合)

HashSet集合不能保证的迭代顺序与元素存储顺序相同。

HashSet集合,采用哈希表结构存储数据,保证元素唯一性的方式依赖于:hashCode()与equals()方法

package com.oracle.demo3;

import java.util.HashSet;

public class HashSetDemo {
    public static void main(String[] args) {
		hash();
	}
    /*
     * set中存储数据是不能重复的
     * 1、计算你要存储的对象的哈希值,然后将这个哈希值放到集合中去看看
     *    有没有相同的哈希值
     * 2、拿着哈希值在集合中找,如果有相同的哈希值,那么就调用equals方法,
     *    "aab".equals("aab"),如果相同,返回true,就判定这是个重复元素,丢掉
     * 3、如果哈希值相同,则调用equals方法,如果返回false,那么存入set
     * */
    public static void hash(){
    	HashSet<String> hs=new HashSet<String>();
    	hs.add("aab");
    	hs.add("aab");
    	hs.add("bbc");
    	hs.add("bbc");
        System.out.println(hs);
    }
}

执行结果:[bbc,aab]   说明set集合中是不能存储重复元素的

HashSet存储自定义类型的数据

如果要保证数据的唯一性依赖于:hashcode()和equals()方法

如果给HashSet中存储JavaAPI中提供的类型的元素时,不需要重写元素的hashcode和equals方法,

因为这两个方法,在JavaAPI的每个类中已经重写完毕,如String类、Integer类等。

HashSet中存放自定义类型元素时,需要重写对象中的hashCode和equals方法,建立自己的比较方式,才能保证HashSet集合中的对象唯一

package com.oracle.demo3;

public class Person {
	String name;
	int age;
    public int hashCode(){
    	return name.hashCode()+age*55;
    }
    public String toString(){
    	return "name为"+name+" age为"+age;
    }
    public boolean equals(Object obj){
    	if(obj==null){
    		return false;
    	}
    	if(this==obj){
    		return true;
    	}
    	if(obj instanceof Person){
    		return ((Person) obj).age==this.age&&((Person)obj).name==this.name;
    	}
    	return false;
    }
	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 Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public Person() {
	}
}

 

package com.oracle.demo3;

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

public class Test {
	public static void main(String[] args) {
		//创建hashset对象
		HashSet<Person> hs =new HashSet<Person>();
		hs.add(new Person("张三", 18));
		hs.add(new Person("李四", 58));
		hs.add(new Person("王五",30));
		hs.add(new Person("李四", 58));
		Iterator<Person> it=hs.iterator();
		while(it.hasNext()){
			Person p=(Person)it.next();
			System.out.println(p);
		}
	}
}

  

LinkedHashSet集合

HashSet保证元素唯一,但是元素存放进去是没有顺序的,那么我们要保证有序,就需要用到LinkedHashSet

HashSet下面有一个子类LinkedHashSet,它是链表和哈希表组合的一个数据存储结构。

package com.oracle.demo3;

import java.util.LinkedHashSet;

public class LinkedHashSetDemo {
     public static void main(String[] args) {
 		LinkedHashSet<String> list=new LinkedHashSet<String>();
        list.add("123");
        list.add("asd");
        list.add("3esd");
        System.out.println(list);
	}
}

判断集合元素是否唯一的原理

ArrayList的contains方法判断元素是否重复原理

ArrayList的contains方法会使用调用方法时,传入的元素的equals方法依次与集合中的旧元素所比较,从而根据返回的布尔值判断是否有重复元素。此时,当ArrayList存放自定义类型时,由于自定义类型在未重写equals方法前,判断是否重复的依据是地址值,所以如果想根据内容判断是否为重复元素,需要重写元素的equals方法

HashSet的add/contains等方法判断元素是否重复原理

Set集合不能存放重复元素,其添加方法在添加时会判断是否有重复元素,有重复不添加,没重复则添加。

HashSet集合由于是无序的,其判断唯一的依据是元素类型的hashCode与equals方法的返回结果。规则如下:

先判断新元素与集合内已经有的旧元素的HashCode值

       如果不同,说明是不同元素,添加到集合。

       如果相同,再判断equals比较结果。返回true则相同元素;返回false则不同元素,添加到集合。

所以,使用HashSet存储自定义类型,如果没有重写该类的hashCode与equals方法,则判断重复时,使用的是地址值,如果想通过内容比较元素是否相同,需要重写该元素类的hashcode与equals方法。

 

以上是关于Java学习List接口Set接口的主要内容,如果未能解决你的问题,请参考以下文章

[知了堂学习笔记]_集合接口list与集合接口set的区别

java学习日记20230414-Set接口

Java学习(set接口HashSet集合)

Java学习---Java核心数据结构(List,Map,Set)使用技巧与优化

java学习之路--集合基础之List和Set部分

Java学习笔记----容器