List、Set、数据结构、Collections

最新推荐文章于 2024-06-25 23:16:46 发布

weixin_41675900

最新推荐文章于 2024-06-25 23:16:46 发布

阅读量104

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/weixin_41675900/article/details/104504430

版权

Java 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

数据结构
栈：先进后出
队列：先进先出
数组：查询快，增删慢
链表：查询慢，增删快
红黑树：趋近于平衡树，查询的速度非常快，查询叶子节点最大次数和最小次数不能超过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);
    }
}