List、Set、数据结构、Collections

List、Set、数据结构、Collections

数据结构
栈:先进后出
队列:先进先出
数组:查询快,增删慢
链表:查询慢,增删快
红黑树:趋近于平衡树,查询的速度非常快,查询叶子节点最大次数和最小次数不能超过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);
    }
}
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/100194.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • [ZZ] cbuffer和tbuffer

    [ZZ] cbuffer和tbuffer

  • mysql性能分析工具_中大型suv横向测评

    mysql性能分析工具_中大型suv横向测评因为工作的原因,我有机会仔细用过市面上几乎所有的MySQL管理工具,对各家的数据库管理软件的特性有了全面的了解。我大概用了20+款MySQL管理工具,从种挑出10款最棒的写了今天的测评。其中7款免费或有社区免费版,另外3种是付费版。当初,在研究这些工具时,我发现网上那些所谓的测评推荐文章里,几乎没人真用过自己文章中写的软件,都是云测评。当时就想自己把所有软件都用一遍,找机会写一篇深度横向测评文章,帮助选择困难症患者,选到最合适大家当下工作场景的工具,节省时间。本文所写软件.

  • 2020最新版MySQL数据库面试题(二)[通俗易懂]

    2020最新版MySQL数据库面试题(二)

  • PreparedStatement详解

    PreparedStatement详解JDBC初步.主要讲了基本访问数据库的步骤.其中第四步提到了用Statement去执行SQL语句.这里介绍个Statement的子类PreparedStatement.PreparedStatement(预处理执行语句)相比其父类Statement主要有以下几个优点.1.可以防止SQL注入.               2.在特定的驱动数据库下相对效率要高(不绝对)   

  • day2 javaee的入门知识「建议收藏」

    day2 javaee的入门知识「建议收藏」1、面向对象与面向过程的区别?面向过程的语言拥有封装、继承、多态的特性,使得整个代码灵活性高,比如Java,C++。容易维护,容易扩展。面向过程的语言直接跟内存打交道,性能要更好,比如java是需要跟虚拟机做交互,先编译解释成机器码。再跟操作系统打交道。大多数面向过程的语言基本都是直接编译成机器码在操作系统上进行执行。所以性能更好。但是java经过多年的发展,性能提升了很大,各位读者要记住javayyds!2、成员变量和局部变量的区别与c++不同的是java中没有全局变量的概念。成员变量:也称

  • 微信公众号高质量技术贴-提炼总结

    微信公众号高质量技术贴-提炼总结微信公众号高质量技术贴过滤掉对自己感觉没有技术相关性的,或者是那种水贴对内容进行归类整理阅读完写下自己的读后感LINUX从无盘启动看Linux启动原理“只读内存”(ROM)—-“基本输入输出系统”(BIOS)—-“硬件自检”(POST)—-“启动顺序”(BootSequence)上电自检—-UEFI固件被加载—-加载UEFI应用—-启动内核及initramfs/sbin/init—-/etc/inittab—-etc/rcN.dLi

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号