目录
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
}
}
390
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
