Collection集合的遍历
迭代器
是什么?
就是集合自带的一种可以遍历集合的方式,可以使用增强for的语法简化这种方式的代码;
代码
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class MyIterator {
public static void main(String[] args) {
Collection<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String next = iterator.next();
}
System.out.println(list);
}
}
增强for
是什么?
是对集合或数组遍历的一种简便方式;
格式
for(数据类型 变量名 : 集合名或者数组名){
此时的变量名表示的就是集合中每一个元素
}
代码
public class MyFor {
public static void main(String[] args) {
Collection<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
System.out.println(list);
for (String s : list) {
System.out.println(s);
}
String[] arr = {"迪丽热巴", "古力娜扎", "稀奇哈哈"};
for(String name: arr){
System.out.println(name);
}
}
}
forEach方法
是什么?
是Collection接口中定义的默认方法,所以所有的实现类对象,都可以直接调用;
怎么用?
所有的实现类对象,都可以直接调用;调用的时候,传递一个带一个参数,不带返回值的lambda即可,此时的这个参数表示的就是集合中的每一个元素;
代码
public class MyForEach {
public static void main(String[] args) {
Collection<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
list.add("ddd");
System.out.println(list);
list.forEach(s -> System.out.println(s));
list.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
}
}
List系列的集合
是什么?
是Collection集合下的一个分支,这个分支的特点是:
1: 有序;
2: 可重复;
3: 有索引;
具体实现类
1. ArrayList 数组结构的集合,特点是: 查询快,增删慢;
2. LinkedList 链表结构的集合,特点是: 查询慢,增删快;
常用方法
凡是带索引的方法都可以使用;
public class MyList {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
for (int i = 0; i < list.size(); i++) {
if (list.get(i).equals("b")) {
list.remove(i);
i--;
}
}
for (int i = list.size() - 1; i >= 0; i--) {
list.remove(i);
}
System.out.println(list);
}
}
set系列集合
是什么?
是Collection集合的一个分支,特点是:
1: 无序;
2: 无索引;
3: 不重复;
具体实现类
1. HashSet集合; 底层是hash表结构,增删改查性能都很高,去重复数据的时候,依赖 hashCode方法和equals方法,**二者缺一不可**!
2. LinkedHashSet集合,是Hashset集合的子类,保证了添加数据和获取数据的顺序一致,其他和hashset集合一样,但是不常用;
3. TreeSet集合,底层是红黑树结构,特点是可以对里面的元素排序;
常用方法
Collection中所有不带索引的方法都可以使用;
HashSet存字符串数据练习
public class MyHashSet {
public static void main(String[] args) {
Set<String> set = new HashSet<>();
set.add("aa");
set.add("dd");
set.add("aa");
set.add("bb");
set.add("cc");
set.add(new String("aa"));
for (String s : set) {
System.out.println(s);
}
System.out.println("aa".hashCode());
System.out.println(new String("aa").hashCode());
}
}
HashSet存手机数据练习
public class Phone {
private String brand;
private double price;
@Override
public String toString() {
return "Phone{" +
"brand='" + brand + '\'' +
", price=" + price +
'}';
}
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public Phone() {
}
public Phone(String brand, double price) {
this.brand = brand;
this.price = price;
}
@Override
public boolean equals(Object o) {
System.out.println("equals方法执行了...");
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Phone phone = (Phone) o;
if (Double.compare(phone.price, price) != 0) return false;
return brand != null ? brand.equals(phone.brand) : phone.brand == null;
}
@Override
public int hashCode() {
System.out.println("hashcode方法执行了...");
int result;
long temp;
result = brand != null ? brand.hashCode() : 0;
temp = Double.doubleToLongBits(price);
result = 31 * result + (int) (temp ^ (temp >>> 32));
return result;
}
}
public class MyHashSet2 {
public static void main(String[] args) {
Set<Phone> set = new HashSet<>();
Phone p1 = new Phone("小米", 999.8);
Phone p2 = new Phone("华为", 999.8);
Phone p3 = new Phone("小米", 999.8);
Phone p4 = new Phone("小米", 999.8);
set.add(p1);
set.add(p2);
set.add(p3);
set.add(p4);
System.out.println(set);
System.out.println(p1.hashCode());
System.out.println(p2.hashCode());
System.out.println(p3.hashCode());
System.out.println(p4.hashCode());
}
}
TreeSet集合
是什么?
可以对里面的元素排序,但是需要我们自己指定排序规则,可以使用自然排序,也可以使用比较器,推荐使用比较器;
怎么用
使用带比较器(也可以写lambda)参数的构造方法创建集合对象;
常用方法依然参考Collection;
public class MyTreeSet {
public static void main(String[] args) {
TreeSet<String> set = new TreeSet<>();
set.add("b");
set.add("b");
set.add("a");
set.add("d");
set.add("c");
System.out.println(set);
TreeSet<String> set2 = new TreeSet<>((s1,s2)->s2.compareTo(s1));
set2.add("b");
set2.add("b");
set2.add("a");
set2.add("d");
set2.add("c");
System.out.println(set2);
}
}
运行结果:
[a, b, c, d]
[d, c, b, a]
TreeSet集合存自定义类型排序
public class Test03 {
public static void main(String[] args) {
TreeSet<Student> set = new TreeSet<>((s1,s2)->{
int i = s1.getAge() - s2.getAge();
return i==0?s1.getName().compareTo(s2.getName()):i;
});
set.add(new Student("张三",18));
set.add(new Student("李四",28));
set.add(new Student("张三",18));
set.add(new Student("王五",25));
System.out.println(set);
}
}
public class Student {
private String name;
private int age;
...(快捷键 Alt+Insert)
集合的构造方法
public class Test {
public static void main(String[] args) {
Random r = new Random();
HashSet<Integer> set = new HashSet<>();
while (set.size()<10){
set.add(r.nextInt(30-10+1)+10);
}
System.out.println(set);
ArrayList<Integer> list = new ArrayList<>(set);
System.out.println(list);
ArrayList<Integer> list2 = new ArrayList<>();
list2.add(3);
list2.add(3);
list2.add(2);
list2.add(2);
list2.add(3);
list2.add(1);
HashSet<Integer> set2 = new HashSet<>(list2);
System.out.println(set2);
}
}
可变参数
是什么?
就是定义方法的时候,形参的数量可以变化的意思;其本质就是一个数组,所以带可变参数的方法内部,可以把可变参数当成数组使用;
怎么用
修饰符 返回值类型 方法名(数据类型... 形参名){
此时的形参名就是一个可变参数,可以当成数组使用
}
与数组相比的优势
当方法的形参是一个数组类型的时候,调用者就必须传递一个实际数组,而方法的形参是一个可变参数的时候,调用者,可以传递0个至多个数据;
注意事项
1. 一个方法中,最多只能使用1个可变参数;
2. 可变参数必须放在参数列表的最右边;
public class Test01 {
public static void methd(int... arr){
System.out.println(Arrays.toString(arr));
}
public static void main(String[] args) {
methd();
methd(2,5,8);
int[] arr = {3,6,9,1,4,7};
methd(arr);
}
}
运行结果:
[]
[2, 5, 8]
[3, 6, 9, 1, 4, 7]
集合工具类Collections
是什么
是一个专门操作集合的工具类,里面都是静态方法,可以通过类名直接调用方法;
Map
是什么?
是java写的一个接口,表示双列集合的意思;就是键值对数据,键不可以重复,但是值可以重复;
常见的实现类
HashMap
如何使用
直接利用空参数的构造方法可以创建对象;
常见方法
1. 添加数据 put(键,值);
2. 删除数据 remove(键);
3. 修改数据 put(键,值); 当键重复的时候,值就会覆盖
4. 获取数据 get(键);
5. 获取数据增强,当取不到数据的时候,给一个默认值; getOrDefault(键,默认值);
6. 获取长度 size();
addAll() 给集合批量添加元素
shuffle() 打乱List集合中的元素顺序
sort() 对list集合中的元素进行升序排序
public class MyCollections {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list,2,5,8,3,6,9,1,4,7);
System.out.println(list);
Collections.shuffle(list);
System.out.println(list);
Collections.sort(list);
System.out.println(list);
Collections.sort(list,(s1,s2)->s2-s1);
System.out.println(list);
}
}
map遍历
根据键找值:
1. 先利用map的keySet方法获取所有的键;
2. 遍历所有的键,可以获取具体的每一个键;
3. 利用map的get方法根据键找值即可;
public class Test01 {
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<>();
map.put("119房间",501);
map.put("116房间",510);
map.put("110房间",502);
Set<String> set = map.keySet();
for (String k : set) {
Integer v = map.get(k);
System.out.println(k+"===>"+v);
}
}
}
键值对对象:(Entry类型)
1. 直接利用map的 entrySet方法,获取所有的键值对对象;
2. 遍历键值对集合,可以得到每一个键值对对象;
3. 面向每一个键值对对象,调用getKey和getValue方法即可获取对应的键和值;
public class Test02 {
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<>();
map.put("119房间",501);
map.put("116房间",510);
map.put("110房间",502);
Set<Map.Entry<String,Integer>> set = map.entrySet();
for (Map.Entry<String, Integer> entry : set) {
String key = entry.getKey();
Integer value = entry.getValue();
System.out.println(key+"===>"+value);
}
}
}