java基础 day10-基本数据类型的封装类，封箱与拆箱，ArrayList及其四种迭代，HashSet，HashMap

基本数据类型的封装类

• java的基本数据类型也被封装为类，8种基本数据类型对应有8个类。

基本数据类型	封装类类型
boolean	java.lang.Boolean
char	java.lang.Character
byte	java.lang.Byte
short	java.lang.Short
int	java.lang.Integer
long	java.lang.Long
float	java.lang.Float
double	java.lang.Double

封箱与拆箱

• 封箱就是将值类型转换为引用类型，
• 拆箱就是将引用类型转换为值类型。

public class Test{
	public static void main(String[] args) {
		//拆箱:引用数据类型->基本数据类型
		Integer a = 15;//与valueOf方法等效
		int b = 20;
		System.out.println(a);
		System.out.println(a + b);
		//装箱：基本数据类型->引用数据类型
		Integer c = Integer.valueOf(10);
		System.out.println(c);
				
		Integer t1 = new Integer(10);
		Integer t2 = new Integer(10);
		System.out.println(t1 == t2);
		System.out.println(t1.equals(t2));

		Integer t3 = 10;
		Integer t4 = 10;
		System.out.println(t3 == t4);
		System.out.println(t3.equals(t4));
		
		//默认情况下缓存-128~127之间
		Integer t5 = 128;
		Integer t6 = 128;
		System.out.println(t5 == t6);
		System.out.println(t5.equals(t6));		
	}
}

Java parseInt() 方法

• 以下内容来自菜鸟教程
• parseInt() 方法用于将字符串参数作为有符号的十进制整数进行解析。如果方法有两个参数， 使用第二个参数指定的基数，将字符串参数解析为有符号的整数。
• 语法：所有 Number 派生类 parseInt 方法格式类似如下：

static int parseInt(String s)

static int parseInt(String s, int radix)//s -- 十进制表示的字符串。radix -- 指定的基数。

• 返回值：parseInt(String s): 返回用十进制参数表示的整数值。parseInt(int i): 使用指定基数的字符串参数表示的整数 (基数可以是 10, 2, 8, 或 16 等进制数) 。

public class Test{
    public static void main(String args[]){
        int x =Integer.parseInt("9");
        double c = Double.parseDouble("5");
        int b = Integer.parseInt("444",16);

        System.out.println(x);
        System.out.println(c);
        System.out.println(b);
    }
}
/*
9
5.0
1092
*/

ArrayList：实现List接口，动态数组，可以自动扩充，有严格顺序，可以有重复元素。

import java.util.ArrayList;

public class Test2 {
	public static void main(String[] args) {
		//动态的数组列表，可以自动扩充大小，底层就是使用数组
		//泛型只能是引用类型，不能是基本数据类型
		ArrayList<Integer> list = new ArrayList<Integer>();
		//装箱：基本数据类型->引用数据类型
		list.add(10);
		list.add(20);
		list.add(30);
		System.out.println(list);
		
		//获取指定下标的元素
		System.out.println(list.get(1));
		//System.out.println(list.get(2));
		System.out.println(list.size());
		
		//是否包含某个字符
		System.out.println(list.contains(4));
		
		//设置某个位置的值
		list.set(1, 2);
		System.out.println("修改后的值为："+list);
		
		ArrayList< Integer> a = new ArrayList<Integer>();
		a.addAll(list);
		System.out.println(a);
		
		//移除某个下标的值
		list.remove(2);
		System.out.println(list);
		
		//清空集合
		list.clear();
		System.out.println(list.size());		
	}
}

ArrayList的迭代

• 传统for循环
• 使用Iterator迭代器
• 隐式迭代器，增强for循环，语法糖
• 使用集合的forEach方法。

import java.util.ArrayList;
import java.util.Iterator;

public class Test3 {
	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		list.add(10);
		list.add(20);
		list.add(30);
		list.add(40);
		
		for (int i = 0; i < list.size(); i++) {
			Integer a = list.get(i);
			System.out.println(a);
		}

		System.out.println("************");
		// 使用迭代器进行迭代
		Iterator<Integer> it = list.iterator();
		while (it.hasNext()) {
			Integer a = it.next();
			System.out.println(a);
		}
		
		System.out.println("***********");
		//使用隐式的迭代器，增强的for循环,进对于集合进行迭代，数字，List，Set，Collection
		for(Integer b :list) {
			System.out.println(b);
		}
		
		System.out.println("***********");
		//使用集合的forEach方法进行迭代
		list.forEach(new MyConsumer());
		
		//list.forEach(Consumer<T>);
		System.out.println("***********");
		list.forEach(System.out::println);

	}
}

哈希HashSet : 无序，不重复

• 判断两个对象相等的依据：首先判断对象的哈希码是否相等，如果相同，则认为相同，如果不同，则通过重写equals的方法进行判断

import java.util.HashSet;
import java.util.Set;

public class Test4 {
	public static void main(String[] args) {
		HashSet<Student> set = new HashSet<Student>();
		HashSet<Student> set2 = new HashSet<Student>();
		set.add(new Student(23, "张三"));
		set2.add(new Student(23, "张三"));
		
		//通过重写的equals和hashCode方法进行比较
		System.out.println(set.equals(set2));
		System.out.println(set.hashCode() == set2.hashCode());
        //遍历输出集合a中的元素
		for (Student a : set) {
			System.out.println(a);
		}

	}

}

学生类

	@Override
	public int hashCode() {
		return Objects.hash(id,nameString);
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		return id == other.id && Objects.equals(nameString, other.nameString);
	}

Map，映射，存储的数据是键值对（key-value）可以有重复元素，是无序的

1. 使用keySet方法获取所有键的集合，然后再进行迭代。
2. 使用values()方法，直接获取所有值。缺点：没有key。
3. 使用entrySet方法，可以获取所有键值对的集合，然后再进行迭代。
4. 使用forEach方法， 进行迭代。

import java.util.HashMap;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

public class Test5 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Map<String, Student> map = new HashMap<String, Student>();
		//添加元素
		map.put("001", new Student(34, "张三"));
		map.put("002", new Student(23, "李四"));
		map.put("003", new Student(22, "王五"));
		System.out.println(map.size());
		
		//获取指定键值
		Student  student= map.get("002");
		System.out.println(student.getNameString());
		
		//移除指定键值的元素
		map.remove("003");
		System.out.println(map);
		
		//将引用复制了一份给map2
		Map<String,Student> map2 = new HashMap<String, Student>();
		map2.putAll(map);
		System.out.println(map2);
		
		//迭代
		Set<String> set = map.keySet();
		for(String s :set) {
			System.out.println(map.get(s));
		}
		
		//返回值的集合
		Collection<Student> s = map.values();
		for(Student stu:s) {
			System.out.println(stu);
		}
		
		
		//返回键值对集合
		Set<Entry<String, Student>> entries = map.entrySet();		
		for (Entry<String, Student> entry : entries) {// 每一个Entry对象，都是一个键值对
			String key = entry.getKey();// 获取键
			Student value = entry.getValue();// 获取值
			System.out.println(value);
		}
		//输出键值对
		map.forEach((k, v) -> System.out.println(k + ":" + v));
		
	}

}