目录
List接口
有序 允许重复public interface List<E> extends Collection<E>
继承自Collection接口的方法
boolean add(E e);向集合末尾追加元素e对象
boolean remove(Object obj)删除第一个和obj相等的元素,
如果没有和obj相等元素,则报异常IndexOutOfBoundsException
常见的List接口的实现类
ArrayList:数组实现,查询快,增删慢,轻量级;(线程不安全)
LinkedList:双向链表实现,增删快,查询慢 (线程不安全)
Vector:数组实现,重量级 (线程安全、使用少)
List接口中的特殊方法
void add(int index, E element); 向指定索引位置index上添加元素element,
原始数据自动后移
E get(int index); 获取指定索引号对应的元素,index应该在[0,size-1]
E set(int index, E element); 用于给指定索引位置上进行赋值,这个位
置上必须有对应的数据(已经赋过值),这里实际上是修改操作,否则
IndexOutOfBoundsException
E remove(int index);删除指定位置的元素,可以返回原始位置上存储的元素
int indexOf(Object o); 查找从左向右第一个o元素的下标索引,如果元素
不存在返回-1
int lastIndexOf(Object o);从右向左查找
对象相等判定使用的是equals方法
sort方法按照自定义比较器对集合中的所有元素进行排序,默认自然序
default void sort(Comparator<? super E> c) {
Object[] a = this.toArray(); //将List集合对象转换为数组
Arrays.sort(a, (Comparator) c); //调用Arrays工具类中的排序方法对数组进行排序
ListIterator<E> i = this.listIterator(); //获取List集合对象中特殊的Iterator迭代器对象
for (Object e : a) { //foreach结构遍历数组中的所有元素
i.next();
i.set((E) e); //修改集合List中迭代器指定的当前位置上的元素
}
}
list.sort(new Comparator<A2>() {
public int compare(A2 o1, A2 o2) {
// 自定义比较规则,按照id从小到大,如果id相等则按照name从大到小
int res = o1.getId().compareTo(o2.getId());
if (res == 0)
res = (o1.getName().compareTo(o2.getName())) * -1;
return res;
}
});
调用方法时要求传入参数为自定义比较器
常见的List接口的实现类
ArrayList:数组实现,查询快,增删慢,轻量级;(线程不安全)
LinkedList:双向链表实现,增删快,查询慢 (线程不安全)
Vector:数组实现,重量级 (线程安全、使用少)
总结List的三种实现类
ArrayList | LinkedList | Vector | |
实现方式 | 数组,按照索引下标访问速度快O(1),但是当删除添加元素时会导致元素的移动,速度慢O(n) | 双向链表,按照索引下标访问速度慢O(n),但是删除添加元素速度快O(1) | 数组,按照索引下标访问速度快O(1),但是当删除添加元素时会导致元素的移动,速度慢O(n) |
是否同步 | 不同步,线程不安全,但是并发高,访问效率高 | 不同步,线程不安全,但是并发高,访问效率高 o | 同步,所以线程安全,但是并发低,访问效率低 |
如何选择 | 经常需要快速访问,较少在中间增加删除元素时使用;如果多线程访问,则需要自行编程解决线程安全问题 | 经常需要在内部增删元素,但是很少需要通过索引快速访问时使用;如果多线程访问,则需要自行编程解决线程安全问题 | 一般不使用,如果在多线程访问时可以考虑使用 |
List接口中的sort方法
package com.yan2;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
/*
* List接口中的sort方法
*/
public class Test2 {
public static void main(String[] args) {
List list = new ArrayList();
list.add(new A2(99L, "zhangsan"));
list.add(new A2(77L, "lisi"));
list.add(new A2(99L, "wangwu"));
list.sort(new Comparator<A2>() {
public int compare(A2 o1, A2 o2) {
// 自定义比较规则,按照id从小到大,如果id相等则按照name从大到小
int res = o1.getId().compareTo(o2.getId());
if (res == 0)
res = (o1.getName().compareTo(o2.getName())) * -1;
return res;
}
});
list.forEach(System.out::println);
}
}
class A2 {
private Long id;
private String name;
public A2(Long id, String name) {
this.id = id;
this.name = name;
}
// ===================================
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "A2 [id=" + id + ", name=" + name + "]";
}
}
最佳匹配原则
package com.yan2;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Random;
public class Test6 {
public static void main(String[] args) {
List list = new ArrayList();
list.add(100);
for (int i = 0; i < 5; i++)
list.add(i);
list.remove(4);//最佳匹配原则
list.remove(Integer.valueOf(100)); //参数是Object
for (int i = 0; i < list.size(); i++)
System.out.println(list.get(i));
}
}
Set集合
无序,不允许重复
public interface Set<E> extends Collection<E>
没有新方法
boolean add(E e);向集合中追加元素e对象,如果出现重复则后添加数据直接丢弃如果进行对象相等比较:
首先调用当前对象所属类中的hashCode方法获取当前对象的hashCode值
按照hashCode值进行比较,
如果hashCode值不相等,则不会调用equals方法,直接得出结论两个对象不相等
如果hashCode值相等,才调用equals方法进行进一步判断
如果equals为真则判断两个对象相等
潜规则:
java要求当两个对象的equals为true时,要求两个对象的hashCode值相等。
hashCode值相等并不一定equals为true
实现类:
HashSet
TreeSet
LinkedHashSet
package com.yan3;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
public class Test1 {
public static void main(String[] args) {
Set set = new HashSet();
set.add(new A1(99L, "zhangsan"));
set.add(new A1(88L, "lisi"));
set.add(new A1(99L, "wangwu"));
set.forEach(System.out::println);
}
}
class A1 {
private Long id;
private String name;
@Override
public int hashCode() {
System.out.println(this+"::hashcode()");
return id.hashCode();
}
//比较规则为:按照id进行比较,如果id相等则对象相等
public boolean equals(Object obj) {
System.out.println(this+"::equals()");
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
A1 other = (A1) obj;
return Objects.equals(id, other.id);
}
public A1(Long id, String name) {
super();
this.id = id;
this.name = name;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "A1 [id=" + id + ", name=" + name + "]";
}
}
Java中采用补码的方式存储整数 [原码 反码 补码]
package com.yan4;
public class Test1 {
public static void main(String[] args) {
// Java中采用补码的方式存储整数 [原码 反码 补码]
//位运算 <<左移位 >>右移位
int kk=12; //00000000 00000000 00000000 001100
System.out.println(Integer.toBinaryString(kk));
int k1=kk>>3;//00000000 00000000 00000000 000001 --1 相当于计算12/2的3次方
System.out.println(k1);
System.out.println(Integer.toBinaryString(k1));
int kk1=3;
int kk2=kk1<<4; //相当于是3*2的4次方
System.out.println(kk2);
int kk3=Integer.MAX_VALUE-1;
System.out.println(kk3+10); //-2147483640
}
}