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