List集合
java.lang.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 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);
//public E remove(int index):移除列表中指定位置的元素,返回的是被移除的元素
//移除元素
String removeE = list.remove(2);
System.out.println("被移除的元素:" + removeE);
System.out.println(list);
//public E set(int index, E element):用指定元素替换集合中指定位置掉元素,返回值是更新前的元素
//最后一个a替换为4
String setE = list.set(4, "A");
System.out.println("被替换的元素:" + setE);
System.out.println(list);
//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);
}
// String r = list.get(5);
// System.out.println(r);//IndexOutOfBoundsException
}
}
LinkedList集合
java.util.LinkedList 集合 implements list接口
LinkedList集合的特点:
1.底层是一个链表结构,查询慢,增删快
2.包含大量操作首位元素的方法
3.使用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
import java.util.LinkedList;
public class Demo02LinkedList {
public static void main(String[] args) {
// show01();
// show02();
show03();
}
// public E removeFirst():移除并返回列表的第一个元素
// public E removeLast():移除并返回列表的最后一个元素
// public E pop():从此列表所表示的对战弹出一个元素
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 first = linked.removeFirst();
System.out.println("被移除的第一个元素:" + first);
String last = linked.removeLast();
System.out.println("被移除的最后一个元素:" + last);
System.out.println(linked);
}
private static void show02() {
//创建LinkedList集合对象
LinkedList<String> linked = new LinkedList<>();
//使用add方法添加元素
linked.add("a");
linked.add("b");
linked.add("c");
System.out.println(linked);
//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);
}
}
private static void show01() {
//创建LinkedList集合对象
LinkedList<String> linked = new LinkedList<>();
//使用add方法添加元素
linked.add("a");
linked.add("b");
linked.add("c");
System.out.println(linked);
///public void addFirst(E e):将指定元素插入列表的开头
// linked.addFirst("www");
linked.push("www");
System.out.println(linked);
//public void addLast(E e):将指定元素添加到此列表的结尾,等效于add()
linked.addLast("com");
System.out.println(linked);
}
}
Vector集合,ArrayList集合,LinkedList集合
1.Vector简介及特点
1、Vector是内部是以动态数组的形式来存储数据的。
2、Vector具有数组所具有的特性、通过索引支持随机访问、所以通过随机访问Vector中的元素效率非常高、但是执行插入、删除时效率比较地下、具体原因后面有分析。
3、Vector实现了AbstractList抽象类、List接口、所以其更具有了AbstractList和List的功能、前面我们知道AbstractList内部已经实现了获取Iterator和ListIterator的方法、所以Vector只需关心对数组操作的方法的实现、
4、Vector实现了RandomAccess接口、此接口只有声明、没有方法体、表示Vector支持随机访问。
5、Vector实现了Cloneable接口、此接口只有声明、没有方法体、表示Vector支持克隆。
6、Vector实现了Serializable接口、此接口只有声明、没有方法体、表示Vector支持序列化、即可以将Vector以流的形式通过ObjectOutputStream来写入到流中。
7、Vector是线程安全的。
2.ArrayList的特点
1、容量不固定,想放多少放多少(当然有最大阈值,但一般达不到)
2、有序的(元素输出顺序与输入顺序一致)
3、非线程安全
4、插入元素的时候可能扩容,删除元素时不会缩小容量,不使用索引的元素查找需要遍历数组,并使用equals比较。
详解方法:
增加:
1、因为是数组实现,ArrayList的代价会大一些,而且会考虑是否需要扩容,首先在原有元素个数上加一为minCapacity,用这个值和Ooject数组大小进行比较(容量),如果这个值大,那么就需要扩容了,将数组的size*1.5+1,如果此时还是minCapacity的话,那么新容量就用minCapacity来表示,然后就是生成新的容量的数组,原来的元素赋值进去即可,如果想更改扩容策略,继承ArrayList,重写ensureCapacity方法即可。
2、add(E)把新添加的元素放到数组的末尾,只需要使用常数的时间。
3、add(int,E)在数组指定位置添加元素,首先确定数组这个位置是否存在和容量是否允许,然后将指定位置后面的所有元素全部向后面移动一个位置,最后才将元素插入进指定位置,使用O(n)的时间代价。
删除:
删除分两种删除,删除对象和按位置删除。
1. 删除对象(空,和非空,但都需要遍历)
1、如果删除的对象为空(null),首先遍历数组元素是否有为空,若有,将使用fastRemove方法删除,具体做法是,将此位置后面的元素全部向前移动一位,最后的那个留空,并可以gc回收了。
2、如果不为空,使用equals方法进行比较,找到了相应的元素后,同样进行faseRemove方法进行删除。
2.按位置删除
1.remove(int)删除指定位置的元素,这是数组的优势,大大提升了性能,仅仅只需要判断index是否越界,剩下的就是直接删除了,不需要遍历。但是该元素后的元素同样需要全部向前移动一位。
获取单个对象:
get(int),首先判断是否越界,然后就是直接返回元素了,这也是数组的优势。
遍历:
常用的迭代器设计模式,iterator方法返回一个父类实现的迭代器。
1、迭代器的hasNext方法的作用是判断当前位置是否是数组最后一个位置,相等为false,否则为true。
2、迭代器next方法用于返回当前的元素,并把指针指向下一个元素,值得注意的是,每次使用next方法的时候,都会判断创建迭代器获取的这个容器的计数器modCount是否与此时的不相等,不相等说明集合的大小被修改过,如果是会抛出ConcurrentModificationException异常,如果相等调用get方法返回元素即可。
判断元素是否存在:
1、首先判断条件元素是否为空,是则遍历集合,有就返回true,否则false。
2、不为空,则使用equals方法,需要遍历集合。
3.LinkedList的特点
是一个双链表,在add和remove时比ArrayList性能好,但get和set时就特别慢了。
恶补下:
双向链表,链表的一种。每个数据结点中都有两个指针,分别指向直接前驱和直接后继。因此,我们可以方便的访问他的前驱结点和后继结点。
1、链表简介:
链表是常用的一种数据结构、关于链表这里只给出简单介绍、只是基础的概念。
1、概念:
如果一个节点包含指向另一个节点的数据值,那么多个节点可以连接成一串,只通过一个变量访问整个节点序列,这样的节点序列称为链表(linked list)
2、单向链表:
如果每个节点仅包含其指向后继节点的引用,这样的链表称为单向链表。
3、双向链表:
每个链表节点,包含两个引用,一个指向前驱节点,一个指向后驱节点,也就是——双向链表。
2、LinkedList的特点:
1、 LinkedList以链表的形式存储数据、对增删元素有很高的效率、查询效率较低、尤其是随机访问、效率不忍直视、
2、 LinkedList继承AbstractSequentialdList(其继承与AbstractList、所以要求其子类要实现通过索引操作元素)、使得LinkedList支持使用索引的“增删改查”操作、
3、LinkedList直接实现了List接口、使其可以内部存储元素有序并且为每个元素提供索引值、
4、LinkedList直接实现了Deque接口、Deque接口继承了Queue、使其可以作为双向链表这种数据结构来使用、操作元素、
5、LinkedList直接实现了Cloneable接口、使其可以复制其中的全部元素
6、在使用ObjectOutputStream/ObjectInputStream流时、会先讲LinkedList的capacity读取/写入到流中、然后将元素一一读取/写入。
HashSet集合
内部无序,封装了HashMap。就是用HashMap的key位来存储值.
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 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);
//使用迭代器遍历set集合
Iterator<Integer> it = set.iterator();
while (it.hasNext()) {
Integer n = it.next();
System.out.println(n);
}
System.out.println("---------------------");
//使用增强for遍历set集合
for (Integer i : set) {
System.out.println(i);
}
}
}
LinkedHashSet集合
java.util.linkedHashSet集合 extends HashSet集合
LinkedHashSet集合特点:
底层是一个哈希表(数组+链表/红黑树)+链表:多了一个条链表(记录元素的存储顺序),保证元素有序
public class Demo04LinkedHashSet {
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]无序不允许重复
HashSet<String> linked = new LinkedHashSet<>();
linked.add("www");
linked.add("abc");
linked.add("abc");
linked.add("itcast");
System.out.println(linked);//[www, abc, itcast]有序,不允许重复
}
}
重写hashCode和equals方法
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 +
'}';
}
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 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);
}
}
哈希值(hashCode)
哈希值:是一个十进制的整数,由系统随即给出(就是对象的地址值,是一个逻辑地址,不是物理地址)
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);//189568618
Person p2 = new Person();
int h2 =p2.hashCode();
System.out.println(h2);//793589513
/*
toString方法的源码:
return getClass().getName() + "@" + Integer.toHexString(HasCode());
*/
System.out.println(p1);//b4c966a
System.out.println(p2);//2f4d3709
System.out.println(p1 == p2);
/*
String 类的哈希值
String类重写Object类的ashCode方法
*/
String s1 = new String("ABC");
String s2 = new String("ABC");
System.out.println(s1.hashCode());//64578
System.out.println(s2.hashCode());//64578
}
}
重写hashCode
public class Person extends Object {
//重写hashCode方法
@Override
public int hashCode() {
return 1;
}
}
Collections集合工具类
java.utils.Collections是集合工具类,用来对集合进行操作。public static <T> boolean addAll(Collection<T> c,T... elements):往集合中添加一些元素public static void shuffle(List<?> list) 打乱集合顺序
import java.util.ArrayList;
import java.util.Collections;
public class Demo01Collections {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
//往集合中添加元素
// list.add("a");
// list.add("b");
// list.add("c");
// list.add("d");
// list.add("e");
//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);//[d, e, a, b, c]
}
}
java.utils.Collections是集合工具类,用来对集合进行操作。public static <T> void sort(List<T> list):将集合中元素按照默认规则排序
注意:
sort(list<> list)使用前提
被排序的集合里边存储的元素,必须实现Comparable,重写接口中的方法compareTo定义排序的规则Comparable接口排序规则:
自己(this) - 参数:升序
import java.util.ArrayList;
import java.util.Collections;
import java.util.concurrent.Callable;
public class Demo02Sort {
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):将集合中元素按照默认规则排序
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);
}
}
java.utils.Collections是集合工具类,用来对集合进行操作。
public static <T> void sort(List<T> list,Comparable<? super T>):将集合中元素按照指定规则排序
Comparator和Comparable的区别
Comparable:自己(this)和别人(参数)比较,自己需要实现Comparable接口,重写比较的规则compareTo方法
Comparator:找一个第三方的裁判,比较两个
Comparator排序规则:
o1 - o2 :升序
o2 - o1 :降序
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Demo03Sort {
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]
Collections.sort(list01, new Comparator<Integer>() {
//重写比较的规则
@Override
public int compare(Integer o1, Integer o2) {
// return 0;
return o1 - o2;//升序
}
});
System.out.println(list01);
ArrayList<Student> list02 = new ArrayList<>();
list02.add(new Student("a迪丽热巴",18));
list02.add(new Student("古力娜扎",20));
list02.add(new Student("杨幂",17));
list02.add(new Student("b杨幂",18));
System.out.println(list02);
// Collections.sort(list02, new Comparator<Student>() {
// @Override
// public int compare(Student o1, Student o2) {
return 0;
// //按照年龄升序
// return o1.getAge() - o2.getAge();
// }
// });
Collections.sort(list02, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
// return 0;
//按照年龄升序
int result = o1.getAge() - o2.getAge();
//如果两人年龄相同,在使用姓名第一个字比较
if (result == 0) {
result = o1.getName().charAt(0) - o2.getName().charAt(0);
}
return result;
}
});
System.out.println(list02);
}
}
重写排序的规则
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();//降序排列
}
}