目录
一、List集合
1.特点
有序集合,这里的有序指的是存取顺序;用户可以精确控制列表中每个元素的插入位置,用户可以通过整数索引访问元素,并搜索列表中的元素,元素可以重复。
1.常用方法
方法名 | 描述 |
---|---|
void add(int index,E element) | 在此集合中的指定位置插入指定的元素 |
E remove(int index) | 删除指定索引处的元素,返回被删除的元素 |
E set(int index,E element) | 修改指定索引处的元素,返回被修改的元素 |
E get(int index) | 返回指定索引处的元素 |
代码示例:
public class Test2 {
public static void main(String[] args) {
//创建集合对象
List<Integer> list = new ArrayList<>();
//添加元素
list.add(1);
list.add(2);
list.add(1);
list.add(3);
list.add(4);
//删除元素,此时删除的是1索引上的元素。
list.remove(1);
//手动装箱,把基本数据类型1变为Integer类型,此时删除元素1
Integer i = Integer.valueOf(1);
list.remove(i);
//修改指定索引的元素
list.set(1,5);
//获取索引1处的元素
System.out.println(list.get(1));
System.out.println("==============");
System.out.println(list);
}
}
二、Set集合
1.Set集合的特点
不可存储重复元素、无序、没有索引、不能使用普通for循环遍历。
2.存储字符串的遍历
public class Test2 {
public static void main(String[] args) {
//创建集合对象
Set<String> set = new TreeSet<>();
//添加元素
set.add("ccc");
set.add("aaa");
set.add("aaa");
set.add("bbb");
// for (int i = 0; i < set.size(); i++) {
// //Set集合是没有索引的,所以不能使用通过索引获取元素的方法
// }
//遍历集合
Iterator<String> it = set.iterator();
while (it.hasNext()){
String s = it.next();
System.out.println(s);
}
System.out.println("-----------------------------------");
for (String s : set) {
System.out.println(s);
}
}
}
3.自然排序Comparable案例:
存储手机对象并遍历,创建TreeSet集合。要求:按照价格从小到大进行排序,价格相同时,按照姓名的字母顺序排序。
//手机类
public class Phone implements Comparable<Phone>{
private String brand;
private int price;
public Phone() {
}
public Phone(String brand, int price) {
this.brand = brand;
this.price = price;
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
@Override
public String toString() {
return "Phone{" +
"brand='" + brand + '\'' +
", price=" + price +
'}';
}
@Override
public int compareTo(Phone o) {
//按照价格排序
int result=this.getPrice()-o.getPrice();
//价格相同,按照品牌排序
result=result==0?this.brand.compareTo(o.getBrand()):result;
return result;
}
}
//测试类
public class Test2 {
public static void main(String[] args) {
//创建手机对象
Phone p1=new Phone("小米",3999);
Phone p3=new Phone("苹果",7999);
Phone p2=new Phone("小米",5999);
Phone p4=new Phone("华为",5999);
//创建集合对象
TreeSet<Phone>ts=new TreeSet<>();
//把手机对象添加到集合中
ts.add(p1);
ts.add(p2);
ts.add(p3);
ts.add(p4);
//遍历集合
for (Phone phone : ts) {
System.out.println(phone);
}
}
}
4.比较器排序Comparator的使用
//存储老师对象并遍历,创建TreeSet集合使用带参构造方法。要求:按照年龄从小到大排序,年龄相同时,按照姓名的字母顺序排序
//老师类
public class Teacher {
private String name;
private int age;
public Teacher() {
}
public Teacher(String name, int age) {
this.name = name;
this.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 String toString() {
return "Teacher{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
//测试类
public class Test2 {
public static void main(String[] args) {
//创建集合对象
TreeSet<Teacher> ts = new TreeSet<>(new Comparator<Teacher>() {
@Override
public int compare(Teacher o1, Teacher o2) {
//o1表示现在要存入的那个元素
//o2表示已经存入到集合中的元素
//主要条件
int result = o1.getAge() - o2.getAge();
//次要条件
result = result == 0 ? o1.getName().compareTo(o2.getName()) : result;
return result;
}
});
//创建老师对象
Teacher t1 = new Teacher("zhangsan",23);
Teacher t2 = new Teacher("lisi",22);
Teacher t3 = new Teacher("wangwu",24);
Teacher t4 = new Teacher("zhaoliu",24);
//把老师添加到集合
ts.add(t1);
ts.add(t2);
ts.add(t3);
ts.add(t4);
//遍历集合
for (Teacher teacher : ts) {
System.out.println(teacher);
}
}
}
三、Map集合
1.常用方法
方法名 | 说明 |
---|---|
V put(K key,V value) | 添加元素 |
V remove(Object key) | 根据键删除键值对元素 |
void clear() | 移除所有的键值对元素 |
boolean containsKey(Object key) | 判断集合是否包含指定的键 |
boolean containsValue(Object value) | 判断集合是否包含指定的值 |
boolean isEmpty() | 判断集合是否为空 |
int size() | 集合的长度,也就是集合中键值对的个数 |
代码示例:
public class Test02 {
public static void main(String[] args) {
//创建集合对象
Map<String,String> map = new HashMap<>();
//添加元素
map.put("张三","A");
map.put("李四","B");
map.put("王五","C");
map.put("赵六","D");
//根据键删除键值对元素
System.out.println(map.remove("张三"));
//移除所有键值对元素:map.clear();
//判断集合是否包含指定的键
System.out.println(map.containsKey("李四"));
//判断集合是否包含指定的值
System.out.println(map.containsValue("B"));
//判断集合是否为空
System.out.println(map.isEmpty());
//int size():集合的长度,也就是集合中键值对的个数
System.out.println(map.size());
//输出集合对象
System.out.println(map);
}
}
2.Map集合的获取方法
方法名 | 说明 |
---|---|
V get(Object key) | 根据键获取值 |
Set<K> keySet() | 获取所有键的集合 |
Collection<V> values() | 获取所有值的集合 |
Set<Map.Entry<K,V>> entrySet() | 获取所有键值对对象的集合 |
示例代码:
public class Test02 {
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
map.put("张三","A");
map.put("李四","B");
map.put("王五","C");
map.put("赵六","D");
//根据键获取值
System.out.println(map.get("李四"));
//获取所有键的集合
Set<String>keyset = map.keySet();
for (String key : keyset) {
System.out.println(key);
}
System.out.println("-----------------");
//获取所有值的集合
Collection<String>values=map.values();
for (String value : values) {
System.out.println(value);
}
System.out.println("-----------------");
//获取所有键值对对象的集合.用getKey()得到键;用getValue()得到值
Set<Map.Entry<String, String>> entrySet = map.entrySet();
for (Map.Entry<String, String> entry : entrySet) {
String key=entry.getKey();
String va=entry.getValue();
System.out.println(key+","+va);
}
}
}
四、Stream流
1.获取Stream流
获取集合的Stream流
//List生成Stream流
List<String> list = new ArrayList<>();
Stream<String> liststream = list.stream();
//Set生成Stream流
Set<String> set = new HashSet<>();
Stream<String> setstream = set.stream();
//Map生成Stream流
Map<String,String> map = new HashMap<>();
Stream<String> keyStream = map.keySet().stream();
Stream<String> valueStream = map.values().stream();
Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();
//数组获取Stream流
String [] name = {"张三","李四","王五"};
//数组可以通过Arrays中的静态方法stream生成流
Stream<String> stream1 = Arrays.stream(name);
//同种数据类型的多个数据可以通过Stream接口的静态方法of生成流
Stream<String> stream2 = Stream.of(name);
2.Stream流中间操作方法
方法名 | 说明 |
---|---|
Stream<T> filter(Predicate predicate) | 用于对流中的数据进行过滤 |
Stream<T> limit(long maxSize) | 返回此流中的元素组成的流,截取前指定参数个数的数据 |
Stream<T> skip(long n) | 跳过指定参数个数的数据,返回由该流的剩余元素组成的流 |
static <T> Stream<T> concat(Stream a, Stream b) | 合并a和b两个流为一个流 |
Stream<T> distinct() | 返回由该流的不同元素(根据Object.equals(Object) )组成的流 |
示例代码:
public class Test003 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
list.add("赵六");
list.add("赵六");
//filter :把集合中以李开头的元素在控制台输出
list.stream().filter(s->s.startsWith("李")).forEach(System.out::println);
System.out.println("-------------");
//limit:取出前两个数据在控制台打印
list.stream().limit(2).forEach(System.out::println);
System.out.println("-------------");
//skip:跳过一个元素,输出剩余元素
list.stream().skip(1).forEach(System.out::println);
System.out.println("-------------");
//concat:合并流
//取前2个数据作为第一个流
Stream<String> s1 = list.stream().limit(2);
//跳过3个数据作为第二个流
Stream<String> s2 = list.stream().skip(3);
//合并两个流,输出不同元素
Stream.concat(s1,s2).distinct().forEach(System.out::println);
}
}
3.Stream流的终结方法
方法名 | 说明 |
---|---|
void forEach(Consumer action) | 对此流的每个元素执行操作 |
long count() | 返回此流中的元素数 |
示例代码:
public class Test003 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
list.add("赵六");
//forEach:对流的每个元素进行操作
list.stream().forEach(System.out::println);
//统计元素的个数
long count = list.stream().count();
System.out.println("此流中元素的个数为:"+count);
}
}
4.收集操作
方法名 | 说明 |
---|---|
R collect(Collector collector) | 把结果收集到集合中 |
工具类Collectors收集方法:
方法名 | 说明 |
---|---|
public static <T> Collector toList() | 把元素收集到List集合中 |
public static <T> Collector toSet() | 把元素收集到Set集合中 |
public static Collector toMap(Function keyMapper,Function valueMapper) | 把元素收集到Map集合中 |
代码示例:
public class Test03 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
list.add("赵六七");
//得到名字为两个字的流
Stream<String> liststream = list.stream().filter(a->a.length()==2);
//把操作完的数据手机到List集合中
liststream.collect(Collectors.toList());
Set<Integer> set = new HashSet<>();
set.add(10);
set.add(20);
set.add(30);
set.add(33);
//得到大于25的流
Stream<Integer> setStream = set.stream().filter(b->b>25);
//把操作完的数据手机到Set集合中
setStream.collect(Collectors.toSet());
}
}
五、Collections工具类
常用的方法示例代码:
public class Test03 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
//添加元素
Collections.addAll(list,"A","C","D","B");
//反转集合
Collections.reverse(list);
//按自然顺序排序
Collections.sort(list);
//随机打乱集合中的元素
Collections.shuffle(list);
//指定集合中索引i的元素和索引i的元素交换
Collections.swap(list,0,list.size()-1);
}
}