List接口及子类(ArrayList、LinkedList)Set接口及其子类(HashSet、LinkedHashSet)、可变参数

List接口

java.util.List接口继承自Collection接口,

List接口特点:

1、有序的集合,存储元素和取出元素的顺序是一致的(存储123 取出123)

2、有索引,包含了一些带索引的方法

3、允许存储重复的元素

List接口中常用方法

  • public void add(int index, E element): 将指定的元素,添加到该集合中的指定位置上。
  • public E get(int index):返回集合中指定位置的元素。
  • public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。
  • public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
public class ListDemo {
    public static void main(String[] args) {
		// 创建List集合对象
    	List<String> list = new ArrayList<String>();
    	
    	// 往 尾部添加 指定元素
    	list.add("图图");
    	list.add("小美");
    	list.add("不高兴");
    	
    	System.out.println(list);
    	// add(int index,String s) 往指定位置添加
    	list.add(1,"没头脑");
    	
    	System.out.println(list);
    	// String remove(int index) 删除指定位置元素  返回被删除元素
    	// 删除索引位置为2的元素 
    	System.out.println("删除索引位置为2的元素");
    	System.out.println(list.remove(2));
    	
    	System.out.println(list);
    	
    	// String set(int index,String s)
    	// 在指定位置 进行 元素替代(改) 
    	// 修改指定位置元素
    	list.set(0, "三毛");
    	System.out.println(list);
    	
    	// String get(int index)  获取指定位置元素
    	
    	// 跟size() 方法一起用  来 遍历的 
    	for(int i = 0;i<list.size();i++){
    		System.out.println(list.get(i));
    	}
    	//还可以使用增强for
    	for (String string : list) {
			System.out.println(string);
		}  	
	}
}

List的子类

ArrayList集合

java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢,查找快。

1、存储结构为数组

2、查询快,增删慢

常用方法和list一样

LinkedList集合

java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合

1、存储结构为链表结构

2、增删快,查询慢

image-20210705162233517

实际开发中对一个集合元素的添加与删除经常涉及到首尾操作,而LinkedList提供了大量首尾操作的方法。这些方法我们作为了解即可:

  • public void addFirst(E e):将指定元素插入此列表的开头。

相当于 push()

  • public void addLast(E e):将指定元素添加到此列表的结尾。

相当于add

  • public E getFirst():返回此列表的第一个元素。

  • public E getLast():返回此列表的最后一个元素。

  • public E removeFirst():移除并返回此列表的第一个元素。

相当于 pop()

  • public E removeLast():移除并返回此列表的最后一个元素。

  • public E pop():从此列表所表示的堆栈处弹出一个元素。

  • public void push(E e):将元素推入此列表所表示的堆栈。

  • public boolean isEmpty():如果列表不包含元素,则返回true。

package com.itheima_List;

import java.util.LinkedList;

public class LinkedListDemo01 {
    public static void main(String[] args) {
        LinkedList<String> link=new LinkedList<>();
        link.add("a");
        link.add("b");
        link.add("v");
        //开头,结尾插元素
        link.addFirst("uu");
        link.addLast("ooo");
        System.out.println(link); //[uu, a, b, v, ooo]
        //public E pop()`:从此列表所表示的堆栈处弹出一个元素。
        System.out.println(link.pop()); //uu
        System.out.println(link);  //[a, b, v, ooo]
        //`public E getFirst()`:返回此列表的第一个元素。
        System.out.println(link.getFirst());  //a

        //push(E e)`:将元素推入此列表所表示的堆栈
        link.push("haha");
        System.out.println(link);  //[haha, a, b, v, ooo]

    }
}


Set接口

java.util.Set接口和java.util.List接口一样,同样继承自Collection接口,它与Collection接口中的方法基本一致。

Set接口的特点:

1、Set接口中存入的元素不出现重复

2、没有索引,没有带索引的方法,也不能使用普通的for循环遍历

3、Set接口中元素无序

HashSet集合

java.util.HashSet是implement Set接口

HashSet特点:

1、不允许存储重复的元素

2、没有索引,没有带索引的方法,也不能使用普通的for循环遍历(可以使用迭代器和增强for)

3、是一个无序的集合,存储的元素和取出的元素的顺序有可能不一致

4、底层是一个哈希表结构(查询的速度非常的快)

package com.itheima_Set;

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

public class SetDemo01 {
    public static void main(String[] args) {
        HashSet<Integer> hashSet=new HashSet<>();
        hashSet.add(12);
        hashSet.add(23);
        hashSet.add(12);
        hashSet.add(9);

        //用迭代器遍历输出
        Iterator<Integer> it = hashSet.iterator();
        while (it.hasNext()){
            Integer i = it.next();
            System.out.println(i); //23,9,12  重复元素未存入
        }
        System.out.println("------");
        //使用增强for遍历
        for(Integer i:hashSet){
            System.out.println(i);  //23,9,12 
        }
    }
}

HashSet集合存储数据的结构(哈希表)

哈希值:是一个十进制的整数,由系统随机给出(就是对象的地址值,是一个逻辑地址,是模拟出来得到地址,不是数据实际存储的物理地址)

在Object类有一个方法,可以获取对象的哈希值

int hashCode()  返回该对象的哈希码值
hashCode方法的源码:
public native int  hashCode();
native:代表该方法调用的是本地操作系统的方法

字符串类的哈希值

String类重写了Object类的hashCode方法

哈希表

jdk1.8版本之前:哈希表=数组+链表

jdk1.8版本之后:哈希表=数组+红黑树(提高查询的速度)

哈希表的特点:速度快

image-20210705174924491

数组结构:把元素进行了分组(相同哈希值的元素时一组)

链表/红黑树结构:把相同哈希值的元素连接到一起

Set集合存储元素不重复的原理

前提:存储的元素必须重写hashCode方法和equals方法

Set集合在调用add方法的时候,add方法会调用元素的hashCode方法和equals方法,判断元素是否重复(先比较哈希值,当哈希值相等时,在调用equals方法比较元素是否相同,再决定是否要存储该元素)

image-20210705180408790

当哈希值相等,调用equals方法还返回true,则二者只存储一个

HashSet存储自定义类型元素

Set集合保证元素唯一:

存储的元素(String,Integer,…Student,Person…),必须重写hashCode方法和equals方法

例如:用HashSet 存储Person,且要求同名字同年龄的人视为同一个人,只能存储一次

package com.itheima_Set;

import java.util.Objects;

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        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;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //重写equals和hashCode方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                name.equals(person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

package com.itheima_Set;

import java.util.HashSet;

public class SetDemo02 {
    public static void main(String[] args) {
        HashSet<Person> hashSet=new HashSet<>();
        Person p1=new Person("浩浩",11);
        Person p2=new Person("昊昊",11);
        Person p3=new Person("昊昊",11);
        hashSet.add(p1);
        hashSet.add(p2);
        hashSet.add(p3);
        System.out.println(hashSet);  //[Person{name='昊昊', age=11}, Person{name='浩浩', age=11}]
    }
}

LinkedHashSet集合

java.util.linkedHashSet集合 extends HashSet 集合

LinkedHashSet集合特点:

底层是一个哈希表(数组+链表/红黑树)+链表,多了一个链表(记录元素的存储顺序),保证有序

package com.itheima_Set;

import java.util.HashSet;
import java.util.LinkedHashSet;

public class LinkedHashSetDemo {
    public static void main(String[] args) {
        HashSet<String> hashSet=new HashSet<>();
        hashSet.add("aaa");
        hashSet.add("ooo");
        hashSet.add("bbb");
        hashSet.add("ccc");
        hashSet.add("aaa");
        System.out.println(hashSet);  //[aaa, ccc, bbb, ooo]无序,且不允许重复


        LinkedHashSet<String> linked=new  LinkedHashSet<>();
        linked.add("aaa");
        linked.add("ooo");
        linked.add("bbb");
        linked.add("ccc");
        linked.add("aaa");
        System.out.println(linked); //[aaa, ooo, bbb, ccc] 有序,但也不允许重复

    }
}

可变参数

是jdk1.5之后出现的新特性

使用前提:当方法的参数列表数据类型已经确定,但是参数的个数不确定,就可以使用可变参数

使用格式:定义方法时使用

修饰符   返回值类型   方法名(数据类型...变量名){}

可变参数的原理:

可变参数底层是一个数组,根据传递参数个数不同,会创建不同长度的数组来存储这些参数。传递的参数个数可以是0个(不传递),1,2,3…多个

package com.itheima_Set;
/*
* 计算(0-n)整数和的方法
* 已知:计算整数的和,不知道要计算几个整数的和,就可以使用可变参数
* */
public class VarArgsDemo {
    public static void main(String[] args) {
        int result=sum(0,1,2,3,4,5);
        System.out.println(result);//15
        int s1=sum(1,2);
        System.out.println(s1);//3
        int s=sum();
        System.out.println(s); //0,创建长度为0的数组

    }
    public static int sum(int...arr){
        int s=0;
        for(int i:arr){
            s+=i;
        }
        //System.out.println(arr.length);
        return s;

    }

}

可变参数的注意事项:

1、一个方法的参数列表只能有一个可变参数

2、如果方法的参数有多个,那么可变参数必须写在参数列表的末尾

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值