Java-数据结构

栈：：

队列：

数组：

链表：

红黑树：

List集合：

package lesson5;

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

/*
    java.util.List接口 extends Collection
    List接口三大特点：
        1.有序集合，存储元素和取出元素的顺序相同
        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:数组索引越界异常
        StringIndexOutOfBoundsException:字符串索引越界异常
 */
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):将指定的元素，添加到该集合的指定位置上
        list.add(2,"haha");
        System.out.println(list);//[a, b, haha, c, d, a]

        //public  E get(int index):返回集合中指定位置的元素
        System.out.println(list.get(2));//haha

        //public E remove(int index):移除集合中指定位置的元素，返回的是被移除的元素
        String s1 = list.remove(2);
        System.out.println(s1);//haha
        System.out.println(list);//[a, b, c, d, a]

        //public E set(int index,E element):用指定元素替换集合中指定位置的元素，返回的是更新前的元素
        String s2 = list.set(3, "wa");
        System.out.println(s2);//d
        System.out.println(list);//[a, b, c, wa, a]

        //List集合遍历有三种方式：
        //使用普通for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("==========");
        //使用迭代器来遍历
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("===========");
        //增强for循环
        for (String s : list) {
            System.out.println(s);
        }

        String a = list.get(5);
        System.out.println(a);//IndexOutOfBoundsException
    }
}

List的子类：
ArrayList集合
LinkedList集合：：：

package lesson5;

import java.util.LinkedList;

/*
    java.util.LinkedList集合 implements List接口
    LinkedList的特点：
        1.底层是一个链表结构：查询慢，增删快
        2.里边包含了大量操作首位元素的方法
        注意：使用LinkedList集合特有的方法，不能使用多态

        public void addFirst(E e):将指定的元素插入此链表的开头
        public void addLast(E e):将指定的元素插入此链表的结尾,此方法等效于add();
        public void push(E e):将元素推入此元素的堆栈,此方法等效于addFirst(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();
        //show02();
        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 f = linked.removeFirst();
        String f = linked.pop();
        System.out.println(f);//a
        System.out.println(linked);//[b, c]
        String l = linked.removeLast();
        System.out.println(l);//c
        System.out.println(linked);//[b]
    }

    /*
        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

        if (!linked.isEmpty()){
            String first = linked.getFirst();
            System.out.println(first);//a
            String last = linked.getLast();
            System.out.println(last);//c
        }
    }

    /*
        public void addFirst(E e):将指定的元素插入此链表的开头
        public void addLast(E e):将指定的元素插入此链表的结尾,此方法等效于add();
        public void push(E e):将元素推入此元素的堆栈,此方法等效于addFirst(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");
        linked.push("www");
        System.out.println(linked);//[www, a, b, c]

        //public void addLast(E e):将指定的元素插入此链表的结尾,此方法等效于add();
        //linked.addLast("com");
        linked.add("com");
        System.out.println(linked);//[www, a, b, c, com]

    }
}

Vector集合：（了解）

HashSet集合：
不包含重复元素，无索引

package lesson1;

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

/*
    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) {
        HashSet<Integer> set = new HashSet<>();
        //使用add方法往集合中添加元素
        set.add(1);
        set.add(3);
        set.add(2);
        set.add(1);
        //使用迭代器遍历集合
        Iterator<Integer> it = set.iterator();
        while (it.hasNext()){
            Integer n = it.next();
            System.out.println(n);//1 2 3
        }
        System.out.println("=========");
        //使用增强for遍历
        for (Integer i : set) {
            System.out.println(i);
        }
    }
}

哈希值：

package lesson1;

public class Person extends Object{
    //重写hashCode方法

    @Override
    public int hashCode() {
        return 1;
        //return super.hashCode();
    }
}

package lesson1;
/*
哈希值：是一个十进制的整数，由系统随机给出(就是对象的地址值，是逻辑地址，是模拟出来的地址，不是数据实际存储的物理地址)
在Object类中有一个方法，可以获取对象的哈希值
    int hashCode() 返回该对象的哈希码值
    hasCode方法的源码：
        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);//189568618      1

        Person p2 = new Person();
        int h2 = p2.hashCode();
        System.out.println(h2);//793589513    1

        /*
            toString方法的源码：
                return getClass().getName()+"@"+Integer.toHexString(hashCode());
         */
        System.out.println(p1);//lesson1.Person@b4c966a    1
        System.out.println(p2);//lesson1.Person@2f4d3709    1
        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("重地".hashCode());// 1179395
        System.out.println("通话".hashCode());// 1179395
    }
}

哈希表：

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

HashSet存储自定义类型元素：

package lesson2;

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

    @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);
    }*/

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

package lesson2;

import java.util.HashSet;

/*
    HashSet存储自定义类型元素
    set集合报错元素唯一：
        存储的元素(String,Integer,...Student,Person),必须重写hashCode方法和equals方法
    要求：
        同名同年龄的人，视为同一个人，只能存储一次
 */
public class Demo03HashSetSavePerson {
    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());//189568618
        System.out.println(p2.hashCode());//793589513

        System.out.println(p1==p2);//false
        System.out.println(p1.equals(p2));//false
        set.add(p1);
        set.add(p2);
        set.add(p3);
        System.out.println(set);//[Person{name='张三', age=18}, Person{name='张三', age=18}, Person{name='张三', age=19}]
    }
}

LinkedHashSet集合：

package lesson2;

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

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

        LinkedHashSet<String> linked = new LinkedHashSet<>();
        linked.add("abc");
        linked.add("abc");
        linked.add("www");
        linked.add("com");
        System.out.println(linked);//[abc, www, com]  有序，不允许重复
    }
}

可变参数：

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

        method("abc",5.5,10,1,true);
    }
    /*
        可变参数的注意事项：
            1.一个方法的参数列表，只能由一个可变参数
            2.如果方法的参数由多个，那么可变参数必须写在参数列表的末尾
     */
        //可变参数的特殊写法：
        public static void method(Object...obj){

        }

    /*
        定义(0~n)个整数和的方法
        已知：计算整数的和，整数类型已经确定int
        参数个数不确定，可使用可变参数
        add()就会创建一个长度为0的数组，new int[0]
     */
    public static int add(int...arr){
        //System.out.println(arr);//[I@10f87f48
        // System.out.println(arr.length);//0
        //定义一个初识化的变量，记录累加求和
        int sum = 0;
        //遍历数组，获取数组中的元素
        for (int i : arr) {
            //累加求和
            sum += i;
        }
        //把求和结果返回
        return sum;
    }

    /*//定义一个方法，计算两个int类型整数的和
    public static int add(int a,int b){
        return a+b;
    }

    //定义一个方法，计算三个int类型整数的和
    public static int add(int a,int b,int c){
        return a+b+c;
    }*/
}