List、Set、数据结构、Collections

全栈程序员站长

发布于 2022-06-29 15:04:07

4970

发布于 2022-06-29 15:04:07

文章被收录于专栏：全栈程序员必看

数据结构栈：先进后出队列：先进先出数组：查询快，增删慢链表：查询慢，增删快红黑树：趋近于平衡树，查询的速度非常快，查询叶子节点最大次数和最小次数不能超过2倍。

List集合

package com.itheima.demo01.List;

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

/* java.util.list接口 extends 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) :用指定元素替换集合中指定位置的元素,返回值的更新前的元素。 注意： 操作索引的时候，一定要防止索引越界异常 IndexOutOfBoundsException:索引越界异常，集合会报 ArrayIndexOutOfBoundsException:数组索引越界异常 StringIndexOutOfBoundException:字符串索引越界异常 */
public class Demo01List {
   
    public static void main(String[] args) {
   
        //创建一个List集合对象，多态
        List<String> list = new ArrayList<>();
        //使用add方法往集合中添加元素
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("a");
        //打印集合
        System.out.println(list);//[a, b, c, d, a] 不是地址重写了toString

        //public void add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。
        //在c和d之间添加一个itheima
        list.add(3,"itheima");
        System.out.println(list);//[a, b, c, itheima, d, a]

        //public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
        String removeE = list.remove(2);
        System.out.println("被移除的元素："+removeE);//被移除的元素：c
        System.out.println(list);//[a, b, itheima, d, a]

        //public E set(int index, E element) :用指定元素替换集合中指定位置的元素,返回值的更新前的元素。
        //把最后的a替换为A
        String setE = list.set(4, "A");
        System.out.println("被替换的元素是："+setE);//被替换的元素是：a
        System.out.println(list);//[a, b, itheima, d, A]

        //list集合遍历有3中方式
        //1.使用普通for循环
        for (int i = 0; i < list.size(); i++) {
   
            //public E get(int index) :返回集合中指定位置的元素。
            String s = list.get(i);
            System.out.println(s);
        }
        System.out.println("============");
        //2.使用迭代器遍历
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
   
            System.out.println(it.next());
        }
        System.out.println("============");
        //3.使用增强for循环
        for (String s : list) {
   //快捷：list.for
            System.out.println(s);
        }

    }
}

List的实现类

Arraylist集合 特点：java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查询快。 LinkedList集合

package com.itheima.demo01.List;

import java.util.LinkedList;

/* java.util.LinkedList集合 implements List接口 LinkedList集合的特点： 1.底层是一个链表结构：查询慢，增删快 2.里边包含了大量操作首尾元素的方法 注意：使用LinkedList集合特有的方法，不能使用多态 public void addFirst(E e) :将指定元素插入此列表的开头。 public void addLast(E e) :将指定元素添加到此列表的结尾。 public void push(E e) :将元素推入此列表所表示的堆栈。 public E getFirst() :返回此列表的第一个元素。 public E getLast() :返回此列表的最后一个元素。 public E removeFirst() :移除并返回此列表的第一个元素。 public E removeLast() :移除并返回此列表的最后一个元素。 public E pop() :从此列表所表示的堆栈处弹出一个元素。 public boolean isEmpty() ：如果列表不包含元素，则返回true。 */
public class Demo02LinkedList {
   
    public static void main(String[] args) {
   
        show01();
        System.out.println("================");
        show02();
        System.out.println("================");
        show03();
    }
     /* public E removeFirst() :移除并返回此列表的第一个元素。 public E removeLast() :移除并返回此列表的最后一个元素。 public E pop() :从此列表所表示的堆栈处弹出一个元素。与removeFirst()效果一样 */
    private static void show03() {
   
        //创建LinkedList集合对象
        LinkedList<String> linked = new LinkedList<>();
        //使用add方法往集合中添加元素
        linked.add("a");
        linked.add("b");
        linked.add("c");
        System.out.println(linked);

        //String s = linked.removeFirst();
        //String s = linked.removeLast();
        String pop = linked.pop();
        System.out.println(pop);//a
        System.out.println(linked);//[b, c]
    }


    /* public E getFirst() :返回此列表的第一个元素。 public E getLast() :返回此列表的最后一个元素。 */
    private static void show02() {
   
        //创建LinkedList集合对象
        LinkedList<String> linked = new LinkedList<>();
        //使用add方法往集合中添加元素
        linked.add("a");
        linked.add("b");
        linked.add("c");

        //linked.clear();//清空集合中的元素 在获取集合中的元素会出现NoSuchElementException异常

        //public boolean isEmpty() ：如果列表不包含元素，则返回true。
        if(!linked.isEmpty()){
   
            String first = linked.getFirst();
            String last = linked.getLast();
            System.out.println("第一个元素："+first+",最后一个元素："+last);
        }

    }

    /* public void addFirst(E e) :将指定元素插入此列表的开头。 public void addLast(E e) :将指定元素添加到此列表的结尾。 public void push(E e) :将元素推入此列表所表示的堆栈。此方法等效于addFirst(E e) */
    private static void show01() {
   
        //创建LinkedList集合对象
        LinkedList<String> linked = new LinkedList<>();
        //使用add方法往集合中添加元素
        linked.add("a");
        linked.add("b");
        linked.add("c");
        System.out.println(linked);//[a, b, c]

        //public void addFirst(E e) :将指定元素插入此列表的开头。
// linked.addFirst("www");
        //public void push(E e) :将元素推入此列表所表示的堆栈。
        linked.push("www");
        System.out.println(linked);//[www, a, b, c]
        //public void addLast(E e) :将指定元素添加到此列表的结尾。
        linked.addLast("com");
        System.out.println(linked);//[www, a, b, c, com]
    }
}

Vector集合

Set接口与List接口一样，都继承自Collection接口 Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复不带索引 HashSet集合

package com.itheima.demo02.Set;

import com.sun.javadoc.SeeTag;

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

/* java.util.Set接口 extends Collection接口 Set接口的特点： 1.不允许存储重复的元素 2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历 java.util.HashSet集合 implements Set接口 HashSet特点： 1.不允许存储重复的元素 2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历 3.是一个无序的集合，存储元素和取出元素的顺序有可能不一致 4.底层是一个哈希表结构（查询的速度非常的快） */
public class Demo01Set {
   
    public static void main(String[] args) {
   
        Set<Integer>  set = new HashSet<>();
        //使用add方法往集合中添加元素
        set.add(1);
        set.add(3);
        set.add(2);
        set.add(1);
        System.out.println(set);//[1, 2, 3]

        //使用迭代器遍历set集合
        Iterator<Integer> it = set.iterator();
        while(it.hasNext()){
   
            System.out.println(it.next());//1 2 3
        }
        System.out.println("=============");
        //使用增强for遍历set集合
        for (Integer i : set) {
   
            System.out.println(i);//1 2 3
        }
    }
}

哈希值

package com.itheima.demo03.hasCode;
/* 哈希值：是一个十进制的整数，由系统随机给出（就是对象的地址值，是一个逻辑地址，是模拟出来得到地址，不是数据实际存储的物理地址） 在Object类有一个方法，可以获取对象的哈希值 int hashCode() 返回该对象的哈希码值. hashCode方法的源码： public native int hashCode(); native:代表该方法调用的是本地操作系统的方法 */
public class Demo01HashCode {
   
    public static void main(String[] args) {
   
        //Person类继承了Object类，所以可以使用Object类的hashCode方法
        Person p1 = new Person();
        int h1 = p1.hashCode();
        System.out.println(h1);//1967205423 |1

        Person p2 = new Person();
        int h2 = p2.hashCode();
        System.out.println(h2);//42121758 |1
        /* toString 方法源码： return getClass().getName() + "@" + Integer.toHexString(hashCode()); */
        System.out.println(p1);//com.itheima.demo03.hasCode.Person@75412c2f
        System.out.println(p2);//com.itheima.demo03.hasCode.Person@282ba1e
        System.out.println(p1==p2);//false

        /* String类的哈希值 String类重写Object类的hashCode方法 */
        String s1 = new String ("abc");
        String s2 = new String("abc");
        System.out.println(s1.hashCode());//96354
        System.out.println(s2.hashCode());//96354
        System.out.println(s1==s2);//false
        System.out.println(s1);//abc
        System.out.println(s2);//abc

        //巧合
        System.out.println("重地".hashCode());//1179395
        System.out.println("通话".hashCode());//1179395

    }
}

package com.itheima.demo03.hasCode;

public class Person extends Object {
   
    @Override
    public int hashCode() {
   
        return 1;
    }
}

HashSet集合存储数据的结构（哈希表）

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

HasgSet存储自定义类型元素

package com.itheima.demo02.Set;

import java.util.HashSet;

/* HashSet存储自定义类型元素 set集合报错元素唯一： 存储的元素（String,Integer,...Student,Person...),必须重写hashCode方法和equals方法 要求： 同名和同年龄的认，视为同一个人，只能存储一次 */
public class Demo03HashSetPerson {
   
    public static void main(String[] args) {
   
        //创建HashSet集合存储Person
        HashSet<Person> set = new HashSet<>();
        Person p1 = new Person("小美女",18);
        Person p2 = new Person("小美女",18);
        Person p3 = new Person("小美女",19);
        System.out.println(p1.hashCode());
        System.out.println(p2.hashCode());

        System.out.println(p1==p2);//比较的是地址值 false
        System.out.println(p1.equals(p2));//未重写equals方法时，所以默认比较地址值 false
                                         //重写之后 true
        set.add(p1);
        set.add(p2);
        set.add(p3);
        System.out.println(set);//[Person{name='小美女', age=19},Person{name='小美女', age=18},Person{name='小美女', age=18}]
        //重写equals和hashCode之后，[Person{name='小美女', age=19}, Person{name='小美女', age=18}]
    }
}

package com.itheima.demo02.Set;

import java.util.Objects;

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

    public Person(String name, int age) {
   
        this.name = name;
        this.age = age;
    }

    public Person() {
   

    }

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

    @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 &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
   

        return Objects.hash(name, age);
    }
}

LinkedHashSet集合

package com.itheima.demo02.Set;

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

/* java.util.LinkedHashSet集合 extends HashSet集合 LinkedHashSet集合特点： 底层是一个哈希表（数组+链表/红黑树）+链表：多了一条链表（记录元素的存储顺序），保证元素有序 */
public class Demo04LinkedHashSet {
   
    public static void main(String[] args) {
   
        HashSet<String> set = new HashSet<>();
        set.add("abc");
        set.add("abc");
        set.add("itcast");
        set.add("www");
        System.out.println(set);//[abc, www, itcast]无序，且不允许重复


        LinkedHashSet<String> linked = new LinkedHashSet<>();
        linked.add("www");
        linked.add("abc");
        linked.add("abc");
        linked.add("itcast");

        System.out.println(linked);//[www, abc, itcast]有序，不允许重复
    }
}

可变参数

package com.itheima.demo04.VarArgs;
/* 可变参数：是JDK1.5之后出现的新特性 使用前提： 当方法的参数列表数据类型已经确定，但是参数的个数不确定，就可以使用可变参数 使用格式：定义方法时使用 修饰符 返回值类型 方法名（数组类型...变量名）{} 可变参数的原理： 可变参数底层就是一个数组，根据传递参数个数不同，会创建不同长度的数组，来存储这些参数 传递的参数个数，可以是0个（不传递），1，2...多个 */
public class Demo01VarArgs {
   
    public static void main(String[] args) {
   
        //int i = add();
        int i =add(10);
        //int i = add(10,20);
        System.out.println(i);
    }

    /* 可变参数的注意事项 1.一个方法的的参数列表，只能有一个可变参数 2.如果方法的参数有多个，那么可变参数必须写在参数列表的末尾 */
    
    //可变参数的（终极）写法
    public static void method(Object obj){
   
        
    }
    /* 定义0-n整数和的方法 已知：计算整数的和，数据类型已经确定int 但是参数的个数不确定，不知道要计算几个整数的和，就可以使用可变参数 add();就会创建一个长度为0的数组，new int[0] add(10);就会创建一个长度为1的数组，存储传递过来的参数 new int[](10); add(10,20);就会创建一个长度为2的数组，存储传递过来的参数 new int[](10,20); ... */
    public static int add(int...arr){
   
// System.out.println(arr);//[I@5f150435 底层是一个数组
// System.out.println(arr.length);//0

        int sum = 0;
        for (int i : arr) {
   
            sum+=i;
        }
        return sum;
    }

}

Collections集合工具类的方法_ andAll&shuffle

package com.itheima.demo05Collections;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

/* -java.util.Collections是集合工具类，用来对集合进行操作，部分方法如下： -public static <T> boolean addAll(Collection<T>) c,T...elements):往集合中添加一些元素。 -public static void shuffle(List<?> list)打乱顺序，打乱集合顺序。 */
public class Demo01Collections {
   
    public static void main(String[] args) {
   
        ArrayList<String> list = new ArrayList<>();
        //public static <T> boolean addAll(Collection<T>) c,T...elements):往集合中添加一些元素。
        Collections.addAll(list,"a","b","c","d","e");
        System.out.println(list);//[a, b, c, d, e]

        //public static void shuffle(List<?> list)打乱顺序，打乱集合顺序。
        Collections.shuffle(list);
        System.out.println(list);//[b, d, e, c, a]
    }
}

sort(List)

package com.itheima.demo05Collections;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

/* -java.util.Collections是集合工具类，用来对集合进行操作。部分方法如下： public static<T> void sort(List<T> list):将集合中元素按照默认规则排序 注意： sort(list<T> list)使用前提 被排序的集合里边存储的元素，必须实现Comparable,重写接口中的方法compareTo定义排序的规则 Comparable接口的排序规则： 自己（this)-参数：升序 反之，降序 */
public class Demo02Sort {
   
    public static void main(String[] args) {
   
        ArrayList<Integer> list01 = new ArrayList<>();
        Collections.addAll(list01,1,3,2);
        System.out.println(list01);//[1, 3, 2]

        //public static<T> void sort(List<T> list):将集合中元素按照默认规则排序
        Collections.sort(list01);//默认是升序
        System.out.println(list01);//[1, 2, 3]

        ArrayList<String> list02 = new ArrayList<>();
        list02.add("a");
        list02.add("c");
        list02.add("b");
        System.out.println(list02);//[a, c, b]

        Collections.sort(list02);
        System.out.println(list02);//[a, b, c]

        ArrayList<Person> list03 = new ArrayList<>();
        list03.add(new Person("张三",18));
        list03.add(new Person("李四",20));
        list03.add(new Person("王五",15));
        System.out.println(list03);//[Person{name='张三', age=18}, Person{name='李四', age=20}, Person{name='王五', age=15}]

        Collections.sort(list03);
        System.out.println(list03);//[Person{name='王五', age=15}, Person{name='张三', age=18}, Person{name='李四', age=20}]
    }
}

package com.itheima.demo05Collections;

public class Person implements Comparable<Person>{
   
    private String name;
    private int age;

    public Person() {
   
    }

    public Person(String name, int age) {
   
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
   
        return "Person{" +
                "name='" + name + '\'' +
                ", 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 int compareTo(Person o) {
   
        //return 0;//认为元素都是相同的
        //自定义比较的规则，比较两个人的年龄（this,参数Person)
        return this.getAge() - o.getAge();//按年龄升序排列
        //return o.getAge()-this.getAge();//按年龄降序排列
    }
}

sort(List,Comparator)

package com.itheima.demo05Collections;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

/* -java.util.Collections是集合工具类，用来对集合进行操作。部分方法如下： public static <T> void sort(List<T> list,Comparator<? super T>):将集合中元素按照指定规则排序。 Comparator 和 Comparable 区别 Comparable:自己(this)和别人（参数）比较，自己需要实现Comparable接口，重写比较的规则compareTo方法 Comparator:相当于找一个第三方的裁判，比较两个 */
public class Demo03Sort {
   
    public static void main(String[] args) {
   
        ArrayList<Integer> list01 = new ArrayList<>();
        Collections.addAll(list01,1,3,2);
        System.out.println(list01);//[1, 3, 2]

        Collections.sort(list01, new Comparator<Integer>() {
   
            @Override
            public int compare(Integer o1, Integer o2) {
   
                //return o1-o2;//升序
                return o2-o1;//降序
            }
        });
        System.out.println(list01);

        ArrayList<Person> list03 = new ArrayList<>();
        list03.add(new Person("c张三",18));
        list03.add(new Person("李四",20));
        list03.add(new Person("b王五",18));

        Collections.sort(list03, new Comparator<Person>() {
   
            @Override
            public int compare(Person o1, Person o2) {
   
                int result = o1.getAge()-o2.getAge();//年龄升序
                //如果两人的年龄相同，再使用姓名的第一个字比较
                if(result==0){
   
                    result= o1.getName().charAt(0)-o2.getName().charAt(0);
                }
                return result;
            }
        });
        System.out.println(list03);
    }
}

发布者：全栈程序员栈长，转载请注明出处：https://javaforall.cn/100194.html原文链接：https://javaforall.cn

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2021年5月1，如有侵权请联系 cloudcommunity@tencent.com 删除

网络安全