一、List集合
（一）List接口介绍
- java.util.list接口继承自collection接口，时单列集合中的一个重要分支，习惯性的会将实现了List接口的对象称为List集合。
- 特点：
- 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33.那么集合中，元素的存储就是按照11、22、33的顺序完成的。
- 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
- 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。
（二）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):用指定元素替换集合中指定位置的元素，返回值的更新前的元素。注意：操作索引时一定要防止索引越界异常。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class list1 {
public static void main(String[] args) {
//使用多态的方法创建一个list集合
List<String> list =new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("a");
System.out.println(list);
//使用list的add方法，指定索引值和元素
list.add(3,"love");
System.out.println(list);
//使用list的remove方法，指定索引值
String s=list.remove(2);//remove方法返回值为移除元素
System.out.println("被移除的元素"+s);
System.out.println(list);
//使用list的set方法，指定索引值和新元素，返回值为之前元素
String m=list.set(2,"shit");
System.out.println("被替换的元素"+m);
System.out.println(list);
System.out.println("-------------------------------------------");
//list集合遍历的三种方法
//普通for循环，使用list中的get方法
for (int i = 0; i < list.size(); i++) {
String n =list.get(i);
System.out.println(n);
}
System.out.println("-------------------------------------------");
//使用迭代器遍历
Iterator it =list.iterator();
while(it.hasNext()){
String t = (String) it.next();
System.out.println(t);
}
System.out.println("-------------------------------------------");
//使用增强for遍历
for (String f:
list) {
System.out.println(f);
}
}
}[a, b, c, d, a]
[a, b, c, love, d, a]
被移除的元素c
[a, b, love, d, a]
被替换的元素love
[a, b, shit, d, a]
-------------------------------------------
a
b
shit
d
a
-------------------------------------------
a
b
shit
d
a
-------------------------------------------
a
b
shit
d
a
二、List的集合子类
（一）ArrayList集合
- java.util.Arraylist集合数据存储的结构是数组结构。元素增删慢，查找快。
（二）LInkedList集合
1、特点
- 底层是一个链表结构，查询慢但增删快
- 里面包含了大量操作首尾元素的方法
- 注意：使用LinkedList集合特有的方法，不能使用多态
2、常用方法
public void addFirst(E e):将指定元素插入此列表的开头
public void addLast(E e):将指定元素添加到此列表的结尾
public void push(E e):将元素推入此列表所表示的堆栈
public E getFirst():返回此列表的第一个元素
public E getLast():返回此列表的最后一个元素
public E pop():从此列表所表示的堆栈处弹出一个元素
public E removeFirst()；移除并返回此列表的第一个元素
public E removeLast():移除并返回此列表的最后一个元素
public boolean isEmpty():如果此列表不包含元素，则返回true
import java.util.LinkedList;
public class linkedlist {
public static void main(String[] args) {
show1();
show2();
show3();
}
private static void show3() {
//删除元素的三种方法
LinkedList<String> list3 = new LinkedList<>();
list3.add("dog");
list3.add("cat");
list3.add("snake");
//利用isEmpty的取反判断集合是否为空
if(!list3.isEmpty()) {
String a = list3.removeFirst();
System.out.println("被移除的第一个元素为：" + a);
String b = list3.removeLast();
System.out.println("被移除的最后一个元素为：" + b);
String c = list3.pop();
System.out.println("被移除的元素为：" + c);
}
}
private static void show2() {
//获取首尾元素的方法
LinkedList<Integer> list2 = new LinkedList<>();
list2.add(857);
list2.add(965);
int a= list2.getFirst();
System.out.println(a);
int b = list2.getLast();
System.out.println(b);
}
private static void show1() {
//插入元素的三种方法
LinkedList<String> list1 = new LinkedList<>();
list1.add("a");
list1.add("b");
list1.add("c");
System.out.println(list1);
list1.addFirst("love" );
list1.addLast("shit");//addLast等效于add方法
list1.push("like");//push等效于addFirst方法
System.out.println(list1);
}
}-
[a, b, c] [like, love, a, b, c, shit] 857 965 被移除的第一个元素为：dog 被移除的最后一个元素为：snake 被移除的元素为：cat
（三）Vector集合
- Vector类可以实现可增长的对象数组，为单线程，运行速度较慢。
二、Set接口
- java.util.Set接口和List接口一样，同样继承自Collection接口，接口中的方法与Collection接口中的方法基本一致。与List接口不同的是，Set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。
- Set集合中取出元素的方式可以采用：迭代器、增强for。因为没有索引方法所以不能使用普通for遍历。
HashSet集合
- 实现了Set接口
1、特点
- 不允许存储重复的元素
- 没有索引，没有索引方法，不能使用for循环遍历
- 是一个无序的集合，存储元素和取出元素的顺序的顺序有可能不一致
- 底层是一个哈希表结构（查询速度非常快）
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class hash {
public static void main(String[] args) {
Set<Integer> list = new HashSet<>();
list.add(1);
list.add(2);
list.add(3);
list.add(1);//不允许出现重复元素会被删除
System.out.println(list);
//使用迭代器循环
Iterator it = list.iterator();
while (it.hasNext()){
int num = (int) it.next();
System.out.println(num);
}
System.out.println("---------------------------------------");
//使用增强for
for (Integer num : list) {
System.out.println(num);
}
}
}[1, 2, 3]
1
2
3
---------------------------------------
1
2
3
2、哈希值
- 是一个十进制的证书，由系统随机给出（就是对象的地址值，是一个逻辑地址，是模拟出来得到的地址值，不是数据实际存储的物理地址）
- 哈希值的获取方法
int hashCode() 返回该对象的哈希码值- String类重写类hashCode方法，使返回的哈希值一致
public static void main(String[] args) {
P p1 =new P();
P p2 = new P();
int h1=p1.hashCode();
int h2=p2.hashCode();
System.out.println(h1+" "+h2);
String s1 =new String("abc");
String s2 =new String("abc");
System.out.println(s1.hashCode()+" "+s2.hashCode());
}2129789493 668386784
96354 963543、哈希表结构
4、Set集合存储元素不重复的原理
4、HashSet存储自定义类型元素
- 给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证集合中的对象唯一。
import java.util.Objects;
public class student {
private String name;
private int age;
public student() {
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof student)) return false;
student student = (student) o;
return getAge() == student.getAge() &&
Objects.equals(getName(), student.getName());
}
@Override
public int hashCode() {
return Objects.hash(getName(), getAge());
}
@Override
public String toString() {
return "student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
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;
}
}import java.util.HashSet;
public class person {
public static void main(String[] args) {
student s1= new student("zhangsan",18);
student s2=new student("zhangsan",18);
student s3 =new student("lisi",20);
HashSet<student> stulist = new HashSet<>();
stulist.add(s1);
stulist.add(s2);
stulist.add(s3);
System.out.println(stulist);//重写hashCode与equals方法后，重复元素不能存储
}
}[student{name='lisi', age=20}, student{name='zhangsan', age=18}]5、LinkedHashSet集合
- 是HashSet下的一个子类，是链表和哈希表组合的一个数据存储结构。保证元素的唯一性和有序性。（有序指以什么顺序输入就以什么顺序输出）
public static void main(String[] args) {
LinkedHashSet<String> linked = new LinkedHashSet<>();
linked.add("www");
linked.add("ooo");
linked.add("abc");
System.out.println(linked);
}
//输出为：[www, ooo, abc]。
三、可变参数
1、使用前提：当方法的参数列表数据类型已经确定，但是参数的个数不确定时可以使用可变参数
2、使用格式：定义方法时使用
修饰符 返回值类型 方法名（数据类型...变量名）{}3、可变参数的原理：
- 可变参数底层是一个数组，根据传递参数个数不同，会创建不同长度的数组，来存储这些参数。传递的参数个数，可以是0个（不传递），1，2...多个
- 注意：一个方法的参数列表，只能有一个可变参数。如果方法的参数有多个，那么可变参数必须写在参数列表的末尾。
public static void main(String[] args) {
int a= add(100,200,300,400,865656);
System.out.println(a);
}
private static int add(int...arr) {
int sum=0;
for (int i : arr) {
sum+=i;
}
return sum;
}866656- 可变参数的特殊写法（终极）
public static void method(Object...obj){
}四、Collections
常用方法
-
public static <T> boolean addAll(Collecton<t> c,T...elements):往集合中添加一些元素。 public static void shuffle（List<?> list):打乱集合顺序
import java.util.ArrayList;
import java.util.Collections;
public class c1 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"a","b","c");
System.out.println(list);
Collections.shuffle(list);
System.out.println(list);
}
}[a, b, c]
[a, c, b]-
public static<T> void sort(List<T> list):将集合中的元素按照默认规则排序
注意：被排序的集合里边存储的元素必须实现Comparble，重写接口中的方法compareTo定义排序的规则。
Comparble接口的排序规则：
- this-参数：升序
- 参数-this ：降序
public class people implements Comparable<people> {
private String name;
private int age;
public people() {
}
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;
}
public people(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "people{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(people o) {
return this.age-o.age;//升序
//return 0.age-this.age:降序
}
}
public class c2 {
public static void main(String[] args) {
ArrayList<String> list1 = new ArrayList<>();
Collections.addAll(list1,"a","c","b","d","e");
Collections.sort(list1);
System.out.println(list1);
ArrayList<Integer> list2= new ArrayList<>();
Collections.addAll(list2,1,3,4,0,8);
Collections.sort(list2);
System.out.println(list2);
ArrayList<people>list3 = new ArrayList<>();
list3.add(new people("zhangsan",18));
list3.add(new people("lisi",25));
list3.add(new people("wangmazi",20));
Collections.sort(list3);
System.out.println(list3);
}
}
[a, b, c, d, e]
[0, 1, 3, 4, 8]
[people{name='zhangsan', age=18}, people{name='wangmazi', age=20}, people{name='lisi', age=25}]
-
public static <T> void sort(List<T>,Comparator<? super T>):将集合中元素按照指定规则排序。 Comparator和Comparable区别： Comparable：自己（this） 和别人（参数) 比较，自己需要实现接口，重写比较的规则 Comparator：相当于找个第三方进行比较 排序规则：o1-o2:升序 o2-o1:降序
public class stu {
private String name;
private int 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;
}
public stu(String name, int age) {
this.name = name;
this.age = age;
}
public stu() {
}
@Override
public String toString() {
return "stu{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class c3 {
public static void main(String[] args) {
ArrayList<Integer> list1 = new ArrayList<>();
list1.add(0);
list1.add(235);
list1.add(5);
Collections.sort(list1, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1-o2;
}
});
System.out.println(list1);
ArrayList<stu> list2 =new ArrayList<>();
list2.add(new stu("zhangsan",18));
list2.add(new stu("lisi",89));
list2.add(new stu("wangwu",22));
list2.add(new stu("wuqi",18));
Collections.sort(list2, new Comparator<stu>() {
@Override
public int compare(stu o1, stu o2) {
int result = o1.getAge()- o2.getAge();
if(result==0){
result= o1.getName().charAt(0)-o2.getName().charAt(0);
}
return result;
}
});
System.out.println(list2);
}
}
[0, 5, 235]
[stu{name='wuqi', age=18}, stu{name='zhangsan', age=18}, stu{name='wangwu', age=22}, stu{name='lisi', age=89}]
7645
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
