目录
集合
集合中可以存储不同的数据,可以存储任何类型(只能存储引用类型)
通过泛型,可以为集合设置一个类型,保证里面的数据类型为同一个
collection接口(单列)
里面定义了单列集合共有的方法
add() 向集合的末尾添加某一元素
addAll() 添加另一集合的全部元素(为同一类型或者有继承关系)
clear() 清空集合中的元素
equals()判断两个集合是否相等
isEmpty()判断集合是否为空
remove()删除指定的元素,成功返回true,没有换回flase
retainAll() 保留指定的元素
size() 集合的元素个数
toArray() 返回集合中所有元素的数组
list接口
List 中的数据对象有顺序且可以重复
ArrayList实现类
ArrayList实现了长度可变的数组，在内存中分配连续的空间。 遍历元素和随机访问元素的效率比较高,插入删除元素的效率比较低
常用方法: add(int index, E element) 添加元素 get(int index) 返回该列表指定位置的元素 indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1
lastIndexOf(Object o)返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1
remove(int index) 删除并返回指定位置元素 removeRange(int fromIndex, int toIndex) 删除指定区间的元素(子类继承使用) set(int index, E element)用指定的元素替换此列表中指定位置的元素。
LinkedList实现类
LinkedList采用链表存储方式。插入、删除元素时效率比较
常用方法: addFirist(Object element)在该列表开头插入指定的元素。
addLast(Object element)在该列表结尾插入指定的元素。 get(int index)返回指定位置的元素 removeFirst()从列表删除和返回第一个元素 removeLast() 从列表删除和返回最后一个元素 getFirst() 返回列表第一个元素 getLast()返回列表最后一个元素
Vector实现类
List接口集合迭代
for循环遍历
import java.util.LinkedList;
public class Demo1 {
public static void main(String[] args) {
LinkedList <String > list=new LinkedList<>();
list.add("a");
list.add("d");
list.add("c");
list.add("a");
list.add("d");
/*
for循环遍历集合,可以从中删除元素
注:删除元素后,元素会向前移动,索引值++,可能会出现错漏问题
*/
for (int i = 0; i <list.size() ; i++) {
for (int j = i+1; j <list.size() ; j++) {
if(list.get(i).equals(list.get(j))){
list.remove(j);
j--;
}
}
}
System.out.println(list);
}
}增强for循环的遍历
import java.util.LinkedList;
public class Demo1 {
public static void main(String[] args) {
LinkedList <String > list=new LinkedList<>();
list.add("a");
list.add("d");
list.add("c");
list.add("a");
list.add("d");
/*
for循环遍历集合,可以从中删除元素
注:删除元素后,元素会向前移动,索引值++,可能会出现错漏问题
*/
for (int i = 0; i <list.size() ; i++) {
for (int j = i+1; j <list.size() ; j++) {
if(list.get(i).equals(list.get(j))){
list.remove(j);
j--;
}
}
}
System.out.println(list);
}
}迭代器遍历（Iterator）
import java.util.LinkedList;
public class Demo1 {
public static void main(String[] args) {
LinkedList <String > list=new LinkedList<>();
list.add("a");
list.add("d");
list.add("c");
list.add("a");
list.add("d");
/*
for循环遍历集合,可以从中删除元素
注:删除元素后,元素会向前移动,索引值++,可能会出现错漏问题
*/
for (int i = 0; i <list.size() ; i++) {
for (int j = i+1; j <list.size() ; j++) {
if(list.get(i).equals(list.get(j))){
list.remove(j);
j--;
}
}
}
System.out.println(list);
}
}
set接口
Set中所存储的元素是不重复的,但是是无序的, Set中的元素是没有索引
HashSet实现类
import java.util.HashSet;
public class HashSetDemo {
public static void main(String[] args) {
/*
HashSet中的元素是不可以重复的
添加元素时调用的add()方法会判断元素是否重复
object中:
public native int hashCode(); 用native修饰的方法是java不定义的,是操作系统对其定义,获取的是内存地址
public boolean equals(Object obj); 在object中,比较的是对象的地址
判断时的方法用的是hashCode()和equals(Object o)
hashCode()如果调用的object中的方法,比较的是内存地址
其他类重写了该方法,比较的是计算出来的是整数型的数据,提高了比较效率
但是不安全,可能会出现哈希值相同,内容不同的情况
equals(Object o) 当哈希值相同时,就会调用该方法比较内容是否相同
*/
Car c1=new Car(1,"宝马");
Car c2=new Car(2,"奔驰");
Car c3=new Car(3,"特斯拉");
Car c4=new Car(1,"宝马");
HashSet<Car>set=new HashSet<>();//如果不在Car类中重写hashCode()和equals(Object o),比较的就是内存地址
set.add(c1);
set.add(c2);
set.add(c3);
set.add(c4);
System.out.println(set);
}
}
import java.util.Objects;
public class Car implements Comparable<Car>{
int num;
String name;
public Car(int num, String name) {
this.num = num;
this.name = name;
}
@Override
public String toString() {
return "Car{" +
"num=" + num +
", name='" + name + '\'' +
'}';
}
@Override
public int compareTo(Car o) {
return this.num-o.num;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Car car = (Car) o;
return num == car.num &&
Objects.equals(name, car.name);
}
@Override
public int hashCode() {
return Objects.hash(num, name);
}
}TreeSet实现类
import java.util.TreeSet;
public class TreeDemo {
public static void main(String[] args) {
/*
TreeSet:可以根据元素的自然顺序排序
添加的元素类型,必须实现排序接口
*/
TreeSet<String>set=new TreeSet();
set.add("a");
set.add("a");
set.add("d");
set.add("c");
set.add("a");
set.add("d");
System.out.println(set);
Car c1=new Car(1,"宝马1");
Car c2=new Car(3,"宝马3");
Car c3=new Car(2,"宝马2");
TreeSet<Car>set1=new TreeSet<>();
set1.add(c1);
set1.add(c2);
set1.add(c3);
System.out.println(set1);
}
}
import java.util.Objects;
public class Car implements Comparable<Car>{
int num;
String name;
public Car(int num, String name) {
this.num = num;
this.name = name;
}
@Override
public String toString() {
return "Car{" +
"num=" + num +
", name='" + name + '\'' +
'}';
}
@Override
public int compareTo(Car o) {
return this.num-o.num;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Car car = (Car) o;
return num == car.num &&
Objects.equals(name, car.name);
}
@Override
public int hashCode() {
return Objects.hash(num, name);
}
}Map接口(双列)
将键映射到值的对象 一个映射不能包含重复的键 每个键最多只能映射到一个值
常用方法
V put(K key,V value) 向集合添加元素
V remove(Object key) 从该地图中删除指定键的映射（如果存在）。
void clear() 清除集合
boolean containsKey(Object key)如果此映射包含指定键的映射，则返回 true 。
boolean containsValue(Object value)如果此地图将一个或多个键映射到指定值，则返回 true
boolean isEmpty()判断集合是否为空 int size() 映射的个数
V get(Object key) 返回到指定键所映射的值，或 null如果此映射包含该键的映射。
Set keySet() 返回此地图中包含的键的Set视图
entrySet() 返回此地图中包含的映射的Set视图
HashMap实现类
1.键是无序的
2.键不能重复,值可以重复
3.可以存储一个为null的键
TreeMap实现类
可以通过键进行排序,作为键的类型必须实现排序接口
HashTable实现类
是线程安全的
Map集合遍历
根据键值对对象找键和值 获取所有键值对对象的集合 遍历键值对对象的集合，获取到每一个键值对对象 根据键值对对象找键和值
import java.util.TreeSet;
public class TreeDemo {
public static void main(String[] args) {
/*
TreeSet:可以根据元素的自然顺序排序
添加的元素类型,必须实现排序接口
*/
TreeSet<String>set=new TreeSet();
set.add("a");
set.add("a");
set.add("d");
set.add("c");
set.add("a");
set.add("d");
System.out.println(set);
Car c1=new Car(1,"宝马1");
Car c2=new Car(3,"宝马3");
Car c3=new Car(2,"宝马2");
TreeSet<Car>set1=new TreeSet<>();
set1.add(c1);
set1.add(c2);
set1.add(c3);
System.out.println(set1);
}
}
import java.util.Objects;
public class Car implements Comparable<Car>{
int num;
String name;
public Car(int num, String name) {
this.num = num;
this.name = name;
}
@Override
public String toString() {
return "Car{" +
"num=" + num +
", name='" + name + '\'' +
'}';
}
@Override
public int compareTo(Car o) {
return this.num-o.num;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Car car = (Car) o;
return num == car.num &&
Objects.equals(name, car.name);
}
@Override
public int hashCode() {
return Objects.hash(num, name);
}
}Collections类
集合类的工具类，与数组的工具类Arrays类似.
addAl l(Col lection c, T... elements);添加元素
binarySearch(List> l ist, T key)二分查找(前提是排序好的) sort(List l ist)排序() sort(List l ist, Comparator c)自定义排序规则排序 swap(List l ist, int i, int j) copy(List dest, List src) ; 注意 dest size需大于等于src.size emptyList() 返回为空的集合,不能添加数据 fi l l(List l ist, T obj)填满集合 max(Col lection col l)返回集合的最大值 min(Col lection col l)返回集合的最小值 replaceAl l(List l ist, T oldVal, T newVal)将列表中一个指定值的所有出现替换为另一个
reverse(List l ist)反转指定列表中元素的顺序
shuffle(List l ist) 随机排序 copy(dest,src)集合复制
public class CollectionsDemo {
public static void main(String[] args) {
List <Integer>list=new ArrayList<>();
list.add(1);
list.add(4);
list.add(9);
list.add(10);
//Collections.addAll(list,6,7,8);//添加元素 后面时可变长度的参数，本质时数组
System.out.println(list);
Collections.sort(list);//排序
System.out.println(list);
System.out.println(Collections.binarySearch(list,9));//二分查找
Collections.swap(list,0,2);//交换指定两个元素的位置
System.out.println(list);
Collections.reverse(list);//逆序
System.out.println(list);
Collections.shuffle(list);//随机排序
System.out.println(list);
List <Integer>list1=new ArrayList<>();
list1.add(10);
list1.add(4);
list1.add(9);
list1.add(10);
list1.add(0);
Collections.copy(list1,list);//将旧集合的元素复制到新集合中 新集合的大小应大于原集合的大小
System.out.println(list1);
}
}泛型
public class Demo1<T> {
/*
泛型：参数化类型 在编译期间对类型进行检测
1.传入的参数为引用类型
2，为传入参数默认是object类型
3.可以传入多个参数
? 无界通配符
?extendT 类型通配符上限,实际传入的类型只能是T或者T的子类
?superT 类型通配符下限,实际传入的类型只能是T或者T的父类
*/
private T num;
public T getNum() {
return num;
}
public void setNum(T num) {
this.num = num;
}
public Demo1(T num) {
this.num = num;
}
public Demo1() {
}
/* public static void main(String[] args) {
Demo1<Integer> d=new Demo1(10);
System.out.println(d.num);
}*/
}
/*
子类也是泛型类，子类和父类的泛型类型要一致 public class Demo2<Integer> extends Demo1
子类不是泛型类，父类要明确泛型的数据类型public class Demo2 extends Demo1<Integer>
*/
/*public class Demo2 extends Demo1<Integer>{
public Demo2(Integer num) {
super(num);
}
}*/
public class Demo2<T> extends Demo1<T>{
public Demo2(T num) {
super(num);
}
public Demo2() {
}
}
153
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
