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:数组索引越界异常 StringIndexOutOfBoundsException:字符串索引越界异常
代码示例： import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class Main { 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之间添加一个lzh list.add(3,"lzh"); System.out.println(list);//[a, b, c, lzh, d, a] //public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。 //移除元素 String removeE = list.remove(2); System.out.println("被移除的元素：" + removeE);//被移除的元素：c System.out.println(list);//[a, b, lzh, 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, lzh, d, A] //List集合遍历有3种方式 //使用普通的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("===================="); //使用迭代器 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); } } }java.util.LinkedList集合 implements List接口
LinkedList集合的特点: 1、底层是一个链表结构:查询慢,增删快 2、里边包含了大量操作首尾元素的方法 3、注意:使用LinkedList集合特有的方法,不能使用多态
代码示例：
import java.util.LinkedList; public class Main { 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);//[a, b, c] //String first = linked.removeFirst(); String first = linked.pop();//与linked.removeFirst()效果相同 System.out.println("被移除的第一个元素：" + first); String last = linked.removeLast(); System.out.println("被移除的第一个元素：" + last); System.out.println(linked); } /** - 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(); System.out.println(first); String last = linked.getLast(); System.out.println(last); } } /** - public void addFirst(E e):将指定元素插入此列表的开头。 - public void addLast(E e):将指定元素添加到此列表的结尾。 - 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");//与linked.addFirst("www")效果一致 System.out.println(linked);//[www, a, b, c] //public void addLast(E e):将指定元素添加到此列表的结尾。此方法等效于 add() linked.addLast("com"); System.out.println(linked); } }java.util.Set接口 extends Collection接口
Set接口的特点: 1、不允许存储重复的元素 2、没有索引,没有带索引的方法,也不能使用普通的for循环遍历
java.util.HashSet集合 implements Set接口
HashSet特点: 1、不允许存储重复的元素 2、没有索引,没有带索引的方法,也不能使用普通的for循环遍历 3、是一个无序的集合,存储元素和取出元素的顺序有可能不一致 4、底层是一个哈希表结构(查询的速度非常的快)
代码示例：
import java.util.HashSet; import java.util.Iterator; import java.util.Set; public class MySet { public static void main(String[] args) { Set<Integer> set = new HashSet<>(); //使用add方法往集合中添加元素 set.add(1); set.add(3); set.add(2); set.add(1); //使用迭代器遍历Set集合 Iterator<Integer> it = set.iterator(); while (it.hasNext()) { System.out.println(it.next());//1 2 3 } //使用增强for遍历Set集合 System.out.println("================"); for (Integer i : set) { System.out.println(i); } } }哈希值:是一个十进制的整数,由系统随机给出(就是对象的地址值,是一个逻辑地址,是模拟出来得到地址,不是数据实际存储的物理地址)
在Object类有一个方法,可以获取对象的哈希值
int hashCode() 返回该对象的哈希码值。
hashCode方法的源码:
public native int hashCode(); native:代表该方法调用的是本地操作系统的方法
public class MyHashCode { public static void main(String[] args) { //Person类继承了Object类，所以可以使用Object类的hashCode方法 Person p1 = new Person(); int h1 = p1.hashCode(); System.out.println(h1); //1163157884 Person p2 = new Person(); int h2 = p2.hashCode(); System.out.println(h2); //1956725890 /** toString方法的源码: return getClass().getName() + "@" + Integer.toHexString(hashCode()); */ System.out.println(p1);//com.lzh.day03.Person@4554617c System.out.println(p2);//com.lzh.day03.Person@74a14482 System.out.println(p1==p2);//false /** String类的哈希值 String类重写Obejct类的hashCode方法 */ String s1 = new String("abc"); String s2 = new String("abc"); System.out.println(s1.hashCode()); System.out.println(s2.hashCode()); System.out.println("重地".hashCode());//1179395 System.out.println("通话".hashCode());//1179395 } }java.util.Set接口和java.util.List接口一样，同样继承自Collection接口，它与Collection接口中的方法基本一致，并没有对Collection接口进行功能上的扩充，只是比Collection接口更加严格了。与List接口不同的是，Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。
Set集合有多个子类，这里我们介绍其中的java.util.HashSet、java.util.LinkedHashSet这两个集合。
import java.util.HashSet; import java.util.Iterator; import java.util.Set; public class MySet { public static void main(String[] args) { Set<Integer> set = new HashSet<>(); //使用add方法往集合中添加元素 set.add(1); set.add(3); set.add(2); set.add(1); //使用迭代器遍历Set集合 Iterator<Integer> it = set.iterator(); while (it.hasNext()) { System.out.println(it.next());//1 2 3 } //使用增强for遍历Set集合 System.out.println("================"); for (Integer i : set) { System.out.println(i); } } }java.util.LinkedHashSet集合 extends HashSet集合
LinkedHashSet集合特点: 底层是一个哈希表(数组+链表/红黑树)+链表: 多了一条链表(记录元素的存储顺序),保证元素有序 import java.util.HashSet; import java.util.LinkedHashSet; public class Main { public static void main(String[] args) { HashSet<String> set = new HashSet<>(); set.add("www"); set.add("abc"); set.add("abc"); set.add("itcast"); 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]有序,不允许重复 } }可变参数:是JDK1.5之后出现的新特性
使用前提: 当方法的参数列表数据类型已经确定,但是参数的个数不确定,就可以使用可变参数.
使用格式：定义方法时使用
修饰符 返回值类型 方法名(数据类型…变量名){}
可变参数的原理: 可变参数底层就是一个数组,根据传递参数个数不同,会创建不同长度的数组,来存储这些参数 传递的参数个数,可以是0个(不传递),1,2…多个
代码示例：
public class Main { public static void main(String[] args) { int i = add(10,20,30,40,50,60,70,80,90,100); System.out.println(i); } /** 定义计算(0-n)整数和的方法 已知:计算整数的和,数据类型已经确定int 但是参数的个数不确定,不知道要计算几个整数的和,就可以使用可变参数 add(); 就会创建一个长度为0的数组, new int[0] add(10); 就会创建一个长度为1的数组,存储传递来过的参数 new int[]{10}; add(10,20); 就会创建一个长度为2的数组,存储传递来过的参数 new int[]{10,20}; add(10,20,30,40,50,60,70,80,90,100); 就会创建一个长度为2的数组,存储传递来过的参数 new int[]{10,20,30,40,50,60,70,80,90,100}; */ public static int add(int...arr) { /*System.out.println(arr);//[I@4554617c 底层是一个数组 System.out.println(arr.length);*/ //定义一个初始化变量，记录累加求和 int sum = 0; for (int i : arr) { //累加求和 sum += i; } return sum; } }public static boolean addAll(Collection c, T… elements):往集合中添加一些元素。 public static void shuffle(List<?> list) 打乱顺序:打乱集合顺序。
代码示例： import java.util.ArrayList; import java.util.Collections; public class Main { 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); } }public static void sort(List list，Comparator<? super T> ):将集合中元素按照指定规则排序
代码示例： import java.util.ArrayList; import java.util.Collections; public class MyCollections{ public static void main(String[] args) { ArrayList<Integer> list01 = new ArrayList<>(); list01.add(1); list01.add(3); list01.add(2); System.out.println(list01);//[1, 3, 2] //public static <T> void sort(List<T> list，Comparator<? super T> ):将集合中元素按照指定规则排序 Collections.sort(list01); //默认是升序 System.out.println(list01); ArrayList<String> list02 = new ArrayList<>(); list02.add("a"); list02.add("c"); list02.add("b"); System.out.println(list02); Collections.sort(list02); //默认是升序 System.out.println(list02); } }注意sort(List list)使用前提： 被排序的集合里边存储的元素,必须实现Comparable,重写接口中的方法compareTo定义排序的规则
练习：创建一个学生类，存储到ArrayList集合中完成指定排序操作。
Student 初始类：
public class Student implements Comparable<Student> { private String name; private int age; public Student() { } public Student(String name, int age) { this.name = name; this.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 String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; } //如果想要集合中的元素完成排序，那么必须要实现比较器Comparable接口。 @Override public int compareTo(Student o) { return this.age-o.age;//升序 } }测试类：
public class Demo { public static void main(String[] args) { // 创建四个学生对象 存储到集合中 ArrayList<Student> list = new ArrayList<Student>(); list.add(new Student("rose",18)); list.add(new Student("jack",16)); list.add(new Student("abc",16)); list.add(new Student("ace",17)); list.add(new Student("mark",16)); /* 让学生 按照年龄排序 升序 */ Collections.sort(list);//要求 该list中元素类型 必须实现比较器Comparable接口 for (Student student : list) { System.out.println(student); } } }