一、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 96354
3、哈希表结构
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}]