集合
- 数组的长度是一旦确定就不能改动,数组元素类型必需一致
- 集合长度不定,集合元素类型不要求一样,只能放引用类型
1.1.集合
1.1.1.集合分类
1.1.1.1. Collection 存放单值
-
List 有序可以重复
ArrayList 底层是数组(一块连续的内存地址),查找和修改比较快,新增(指定索引位置插入)和删除比较 慢;
LinkedList 底层是双向链表,查找和修改相对较慢,新增和删除相对比较快;
Vector,底层也是数组,和ArrayList一致;内部方法加了线程同步,性能较低;
-
Set 无序不可重复
HashSet 底层是HashMap 在进行比较两个对象是否相等的时候,使用equals进行比较,还会计 算对象的hash值
LinkedHashSet是HashSet子类,底层是LinkedHashMap;元素的插入顺序和遍历顺序一致;
TreeSet底层用到了红黑树,集合元素会进行排序;要求插入的类型实现Comparable接口,或者 提供一个Comparator的实现类
list中常用方法1
public static void main(String[] args) {
//父类引用指向子类对象
List arrayList = new ArrayList();
// isEmpty判断list为空吗
System.out.println("是否为空" + arrayList.isEmpty());
//add 是追加
arrayList.add("1");
arrayList.add("2");
arrayList.add("3");
// add指定索引位置添加的时候,index不能超集合元素个数
arrayList.add(3, "4");
//把集合元素直接打印出来
System.out.println(arrayList);
//获取list大小
int size = arrayList.size();
System.out.println(size);
// contains是否包含指定的集合元素
System.out.println("是否包含:" + arrayList.contains("456"));
// toArray把list转成数组
/* Object[] objects = arrayList.toArray();
System.out.println(Arrays.toString(objects));*/
//移除集合元素,指定索引删除或者指定元素删除
arrayList.remove(3);
arrayList.remove("4");
System.out.println(arrayList);
}
list 常用方法2
public static void main(String[] args) {
List arrayList = new ArrayList();
arrayList.add("1");
arrayList.add("2");
arrayList.add("3");
List arrayList2 = new ArrayList();
arrayList2.add("1");
arrayList2.add("2");
//集合是否包含另一个集合(集合中每个集合元素都有包含在内)
boolean b = arrayList.containsAll(arrayList2);
System.out.println(b);
// 添加集合(每个集合元素添加进去)
arrayList.addAll(arrayList2);
System.out.println(arrayList);
// 按指定的集合进行删除
// arrayList.removeAll(arrayList2);
System.out.println(arrayList);
//清空集合元素
// arrayList.clear();
System.out.println(arrayList);
//索引从0开始
System.out.println(arrayList.get(2));
// 指定索引修改集合元素
arrayList.set(2, "abc");
System.out.println(arrayList);
System.out.println("指定元素首次出现的索引位置:" + arrayList.indexOf("1"));
System.out.println("指定元素最后一次出现的索引位置:" + arrayList.lastIndexOf("1"));
// 截取子集合,起始索引包含,尾部索引不包含
List list = arrayList.subList(2, arrayList.size());
System.out.println(list);
set 常用方法
public static void main(String[] args) {
HashSet<String> strings = new HashSet<>();
String str1 = new String("abc");
String str2 = new String("abc");
//注意点:abc只会插入一次
strings.add(str1);
strings.add(str2);
// str1.equals(str2)
System.out.println(strings);
System.out.println(strings.size());
Object[] objects = strings.toArray();
// set转数组
System.out.println(Arrays.toString(objects));
}
list/set的遍历方式
1,对list遍历
public static void main(String[] args) {
ArrayList<String> stArr = new ArrayList<>();
stArr.add("aa");
stArr.add("bb");
stArr.add("cc");
//1,普遍for循环
for (int i = 0; i < stArr.size(); i++) {
System.out.println(stArr.get(i));
}
//2,增强for循环
for (String s : stArr) {
System.out.println(s);
}
System.out.println("==============");
//3,使用迭代器遍历
Iterator<String> iterator = stArr.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
System.out.println("++++++++++++++++");
//4,使用forEach遍历
stArr.forEach(s -> {
System.out.println(s);
});
}
2,对set进行遍历
public static void main(String[] args) {
HashSet<String> strings = new HashSet<>();
strings.add("a");
strings.add("b");
strings.add("c");
//1,增强for循环
for (String string : strings) {
System.out.println(string);
}
//2,使用迭代器遍历
Iterator<String> iterator = strings.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
//3,
strings.forEach(str -> {
System.out.println(str);
});
}
1.1.1.2. Map 存放成对的值
1.2.匿名内部类和lambda表达式
1,匿名内部类
如果一个接口上面 @FunctionalInterface表示这是一个功能性接口,里面的抽象方法只有一个;
匿名内部类的使用:匿名内部类,一次性的,只能使用一次,做不到代码重用
public static void main(String[] args) {
// 匿名内部类,一次性的,只能使用一次,做不到代码重用
TreeSet<Student> strings = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getName().compareTo(o2.getName());
}
});
strings.add(new Student("anne"));
strings.add(new Student("jerry"));
strings.add(new Student("anne"));
System.out.println(strings);
}
使用
public static void main(String[] args) {
// 匿名内部类,一次性的,只能使用一次,做不到代码重用
TreeSet<Student> strings2 = new TreeSet<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getName().compareTo(o2.getName());
}
});
//lambda表达式,1.8之后出现的;接口中只有一个抽象方法的时候可以使用
TreeSet<Student> strings = new TreeSet<>((a, b) -> {
return a.getName().compareTo(b.getName());
});
strings.add(new Student("anne"));
strings.add(new Student("jerry"));
strings.add(new Student("anne"));
System.out.println(strings);
}