全网最细致的JavaAPI练习与集合笔记

Java相关API练习

Integer

该类介绍：Integer：位于java.lang包内
该类为基本数据类型int的包装类，介绍该类的主要方法

1. Integer(int/String),构造方法，将整数或字符串放入，包装成整数对象，又称为 “装箱 ”
2. valueOf(),静态方法，将整数包装成Integer对象
3. intValue(),返回对象的整数数值，称为“拆箱”
4. static int parseInt(String s), 将字符串转换为int类型的整数并返回

		//创建Integer包装类对象并放入参数12，自动装箱
        Integer i1 = new Integer(12);
        System.out.println(i1);//输出12
        //创建Integer包装类对象并放入String类型参数12，自动装箱
        Integer i2 = new Integer("12");
        System.out.println(i2);
        //输出234，手动装箱
        System.out.println(Integer.valueOf(234));
        //拆箱，将Integer包装类对象转为int基本数据类型
        int i3 = i1;
        //输出12
        System.out.println(i3);
        //将字符串1234解析为int类型，前提传入字符串可以转为int类型
        int i4 = Integer.parseInt("1234");

String

String类位于java.lang包内，String类用于封装字符串序列
String类常用方法：

1. contains()，判断字符串是否包含某内容
2. charAt(), 根据参数制定的下标返回对应位置的字符
3. int length(), 返回字符串的长度
4. boolean equals(Object o), 用于判断调用字符串和参数字符串是否相等，重写了Object类的equals方法
5. boolean equalsIsIgnoreCase(String anotherString), 判断是否相等但忽略大小写
6. boolean endsWith(String suffix), 判断当前字符串是否以suffix为结尾
7. boolean startWith(String prefix), 判断当前字符串是否以prefix为开头
8. String toLowerCase()， 将调用字符串全部转为小写
9. String toUpperCase(), 将调用字符串全部转为大写
10. String trim(), 将两边空白字符清空
11. int indexOf(String str) 返回传入字符串第一次出现的下标位置，如果不存在，返回-1
12. int lastIndexOf(String str) 返回传入字符串最后一次出现的位置，如果不存在，返回-1
13. String substring(int beginIndex) 截取从beginIndex开始直至字符串结尾的所有字符并返回
14. String substring(int beginIndex, int lastIndex), 截取从beginIndex（包含开始字符）开始的字符至lastIndex（不包含结束位置）结束位置的字符并返回
15. valueOf(int i) 将int类型转为String字符串
    代码演示：

		//创建字符串对象并赋值
		String str = " this is a test of java ";
		//将str字符串两边空白字符清空
		System.out.println("将str字符串两边空白字符清空：：" + str.trim());
		//查找str字符串是否存在this
		System.out.println("str字符串是否存在this：：" + str.contains("this"));
		//查找5下标是什么字符
		System.out.println("str字符串中下标为5的字符是：" + str.charAt(5));
		//返回字符串长度
		System.out.println("str字符串长度为：" + str.length());
		//判断str字符串是否与This Is a Test Of Java相等
		String equStr = "This Is a Test Of Java";
		System.out.println("str字符串是否与This Is a Test Of Java相等：：" + str.equals(equStr));
		//判断str字符串是否与This Is a Test Of Java相等
		System.out.println("忽略大小写判断str字符串是否与This Is a Test Of Java相等：：" + str.equalsIgnoreCase(equStr));
		//判断str字符串是否以a结尾
		System.out.println("str字符串是否以a结尾：：" + str.endsWith("a"));
		//str字符串是否以a开头
		System.out.println("str字符串是否以a开头：：" + str.startsWith("a"));
		//将str字符串全转小写
		System.out.println("将str字符串全转小写：：" + str.toLowerCase());
		//将str字符串全转大写
		System.out.println("将str字符串全转大写：：" + str.toUpperCase());
		//在str字符串中查找a第一次的位置
		System.out.println("str字符串中查找a第一次的位置：：" + str.indexOf("a"));
		//在str字符串中查找a最后一次的位置
		System.out.println("str字符串中查找a最后一次的位置：：" + str.lastIndexOf("a"));
		//截取str字符串从1开始到最后的字符串，因为第一个是空格，所以是全部内容
		System.out.println("截取str字符串从1开始到最后的字符串：：" + str.substring(1));
		//截取str字符串从3开始至8最后的字符串
		System.out.println("截取str字符串从3开始至8最后的字符串：：" + str.substring(3, 8));
		//将数字转换为字符串
		System.out.println("将数字转换为字符串：：" + str.valueOf(3244));

String缓冲类

为什么要有String缓冲类，因为String类是固定的值，一旦创建后，无法修改，如图，OracleJavaString类源码：

String源码定义创建出来的对象都是最终的，不可修改的，如果想要修改String类，那就创建新对象将旧的值赋值给新对象，旧对象还在占用空间，再次赋值为新的对象，所以引进了String缓冲类，该类可实现字符串的修改且在本对象修改。

StringBuffer&StringBuilder

这两个类都位于java.lang包内

两者之间的异同：
相同点：两者都是用于描述可变字符序列的
不同点： StringBuffer类是早期提供的，支持线程安全，但是效率低，StringBuilder类是后期提供的，不支持线程安全，效率高，建议使用此类
介绍方法：这两个类方法基本没区别：

1. java.lang.StringBuilder(String str) , 有参构造方法,根据参数修改可变字符串对象
2. int capacity()，用于获取调用对象的容量并返回。初始容量为字符串长度+16
3. int length()，用于获取长度（字符的个数）并返回
4. StringBuilder insert(int offset, String str)，在offset位置插入str字符串
5. StringBuilder append(String str)，在源字符串后面附加字符串
6. StringBuilder delete(int start, int end)，删除从start开始end结束的字符串
7. StringBuilder replace(int start, int end, String str), 将从start开始至end结束的内容替换为str字符串
8. StringBuilder reverse()，将源字符串反转
   代码演示

		//初始化StringBuilder类并将参数放入
		StringBuilder sbf = new StringBuilder("this is a java");
		System.out.println("sbf的内容为：：" + sbf);
		//获取sbf对象容量
		System.out.println("获取sb对象容量：：" + sbf.capacity());
		//获取sbf对象内容的长度
		System.out.println("获取sbf对象内容的长度：：" + sbf.length());
		//在指定的位置插入字符串
		System.out.println("在指定的位置插入字符串：：" + sbf.insert(8, "of "));
		//在源字符串后面附加字符串
		System.out.println("在源字符串后面附加字符串：：" + sbf.append("!!"));
		//删除起始位置至结束位置的内容
		System.out.println("删除起始位置至结束位置的内容：：" + sbf.delete(5, 7));
		//将起始位置至借书位置的内容替换为指定内容
		System.out.println("将起始位置至借书位置的内容替换为指定内容：：" + sbf.replace(5, 8, "is!"));
		//将源字符串反转
		System.out.println("将源字符串反转：：" + sbf.reverse());

Date

Date类位于java.util包内，用来操作日期
介绍Date类常用方法：
Date()，无参构造方法，获取当前日期对象（精确到毫秒 1000毫秒= 1秒）
Date(time)，有参构造方法，根据时间参数获得对应的Date对象
getTime()， 获取从1970年开始至当前的毫秒数
setTime(long time)，设置指定的毫秒数
代码演示

		//初始化date对象
		Date date = new Date();
		//输出当前日期
		System.out.println(date);
		//初始化date2对象设置毫秒数
		Date date2 = new Date(21324354657643L);
		System.out.println(date2);
		//获取从1970年至现在的毫秒数
		System.out.println(date.getTime());
		//设置毫秒数
		date.setTime(12343543423L);
		System.out.println(date);

SimpleDateFormat

该类主要用于格式化日期对象
该类方法如下：

1. SimepleDateFormat(pattrn) 有参构造方法，根据参数的格式来格式化日期 y:年份 M:月份 d:日期 h:小时 m:分钟 s:秒
2. format(Date date) 格式化，将日期对象格式化为字符串
3. parse() 将字符串解析成日期对象

		//初始化日期对象
		Date date = new Date();
		//初始化格式日期对象
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		//将date对象解析为字符串
		System.out.println(sdf.format(date));
		//将字符串解析成日期对象
		String str = "2020-04-12 13:23:33";
		Date date2 = null;
		//捕获异常
		try {
			date2 = sdf.parse(str);
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		//再次将date对象解析为字符串
		System.out.println(sdf.format(date2));

Calendar

Calendar类是日历类，该类将所有可能用到的时间信息封装为静态成员变量，方便获取
获取方式:
Calendar为抽象类，所以不可被实例化，内部指定了初始化对象的静态方法getInstance()，使用默认时区和语言环境获得一个日历
常用方法：

1. get(int field) 返回给定给定日历的字段的值。
2. set(int field, int value)，将给定的日历字段设置为给定值
3. add(int field, int amount)，根据日历的规则，为给定的日历字段添加或减去指定的时间量
4. getTime()，返回一个标示此Calendar的毫秒数

代码演示：

		//初始化Calendar类，创建对象方式，调用静态方法来实现实例化
		Calendar cal = Calendar.getInstance();
		//输出当前日期的年份
		System.out.println(cal.get(Calendar.YEAR));
		//设置当前的年份为2020
		cal.set(Calendar.YEAR, 2020);
		System.out.println(cal.get(Calendar.YEAR));
		//增加年份2到2022
		cal.add(Calendar.YEAR, 2);
		System.out.println(cal.get(Calendar.YEAR));
		//返回当前的毫秒数
		System.out.println(cal.getTime());
		//格式化日期对象
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh时mm分ss秒");
		//将格式化好的日期对象赋值给str
		String str = sdf.format(cal.getTime());
		System.out.println(str);

集合练习

Collection集合

Collection集合是最高层接口，该类子类有List，Set接口
Collection的最基本单位单个字符
因为Collection是接口，所以在Collection中生命的方法，在子类中都可调用
介绍Collection接口的方法：

1. boolean isEmpty() 判断当前集合是否为空
2. int size() 获取集合内容的长度
3. boolean add(E e)，向集合中添加指定类型的元素
4. boolean addAll(Collection col)，向集合中添加指定集合的全部内容
5. boolean remove(E e)，删除集合中指定的元素
6. removeAll(Collection c)，删除指定类型的集合
7. void clear()，清空当前集合
8. boolean contains(Object o)，判断当前对象在集合中是否存在
9. boolean containsAll(Collection c)，判断当前集合是否存在某一个集合中
   代码演示Collection集合方法：

		Collection<String> col = new ArrayList<String>();
		//向集合中添加指定元素
		col.add("a");
		col.add("b");
		col.add("c");
		col.add("d");
		//判断当前集合是否为空
		System.out.println("判断当前集合是否为空：" + col.isEmpty());
		//获取集合内容的长度
		System.out.println("获取集合内容的长度：" + col.size());
		//向集合中添加指定集合的全部内容
		Collection<String> col2 = new ArrayList<>();
		col2.add("e");
		col2.add("f");
		col2.add("j");
		col.addAll(col2);
		System.out.println("向集合col中添加col2集合的全部内容" + col);
		//删除集合中的j元素
		col.remove("j");
		System.out.println("删除集合中的j元素：" + col);
		//删除col2集合
		col.removeAll(col2);
		System.out.println("删除col2集合：" + col);
		//清空当前集合
		col.clear();
		System.out.println("清空当前集合col内容：" + col);
		//判断col集合中元素是否存在
		System.out.println("判断col集合中元素a是否存在：" + col.contains("a"));
		//判断col2集合是否存在col1集合中
		System.out.println("判断col2集合是否存在col1集合中：" + col.containsAll(col2));

泛型

目前，集合中虽然可以存储不同的类型，其原因是将所有类型的元素都包装成Object类型，但从集合中取出的时候，必须降至类型转换，过程比较繁琐，而且转换时可能发生转换异常

为了避免上述错误的发生，从jdk1.5开始，加入了泛型机制，大大方便了程序的开发，减少异常的发生，
语法格式：
集合接口/实现类<引用数据类型> = new 集合实现类<引用数据类型>();
List< Person > list = new ArrayList< Person >();
明确指定只能存Person类型的数据，获取取数据时，只能取出Person类型的数据，不再用强制类型转换。

List

List是Collection下的一个接口，主要用于线性表数据结构，是ArrayList和LinkedList的间接父类。List除了从Collection集合继承的方法外，List 集合里添加了一些根据索引来 操作集合元素的方法。

1. void add(int index, Object ele):在index位置插入ele元素
2. Object get(int index):获取指定index位置的元素
3. int indexOf(Object obj):返回obj在集合中首次出现的位置
4. int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
5. Object remove(int index):移除指定index位置的元素，并返回此元素
6. Object set(int index, Object ele):设置指定index位置的元素为ele

		List<String> list1 = new ArrayList<String>();
		list1.add("a");
		list1.add("b");
		list1.add("d");
		list1.add("e");
		list1.add("b");
		//在指定位置增加元素
		list1.add(2,"c");
		System.out.println("在指定位置增加元素：" + list1);
		//获取指定目标
		System.out.println("获取指定目标：" + list1.get(2));
		//获取b在集合中首次出现的位置
		System.out.println("获取b在集合中首次出现的位置：" + list1.indexOf("b"));
		//获取b在集合中最后一次出现的位置
		System.out.println("获取b在集合中最后一次出现的位置：" + list1.lastIndexOf("b"));
		//移除指定元素
		list1.remove(2);
		System.out.println("移除指定元素：" + list1);
		//设置指定的位置为指定的元素
		list1.set(2, "C");
		System.out.println("设置指定的位置为指定的元素：" + list1);

ArrayList

该类实现了List接口，该类的特点查询快，循环遍历快，缺点是插入删除效率不高。

LinkdeList

该类实现了List接口，该类的特点插入，删除快，循环遍历慢。
LinkdedList: 双向链表，内部没有声明数组，而是定义了Node类型的first和last，用于记录首末元素
总结：ArrayList和LinkedList的方法在逻辑上完全一样，只是在性能上的差别，ArrayList更适合随机访问及遍历元素，LinkedList更适合于删除，插入元素，在性能要求不是很高的情况下可以忽略这个差别。

Set

Set集合位于java.util包内，是Collection的子接口，特点是元素不能重复，该接口主要实现类：HashSet，TreeSet
HashSet类的底层是一张哈希表实现，散列存放，无序
TreeSet类的底层采用一颗二叉树实现，有序存放，有序

Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败。Set 判断两个对象是否相同不是使用 == 运算符，而是根据 equals() 方法。

HashSet

HashSet按Hash算法来存储集合中的元素，因此具有很好的存取，查找，删除 性能。HashSet具有以下特点：

1. 不能保证元素的排列顺序
2. HashSet是线程不安全的
3. 集合元素可以是null

HashSet底层也是数组，初始容量为16。
代码示例：

	Set<Integer> haset = new HashSet<>();
		haset.add(1);
		haset.add(3);
		haset.add(2);
		haset.add(4);
		haset.add(66);
		//再次添加66
		haset.add(66);
		System.out.println(haset);

可以看出，HashSet是无序的，且数据不可重复。

TreeSet

TreeSet是有序的，且不可重复，该类底层由二叉树实现，有序排放，看例子
自然排序：
题目：现有Person类，属性Id，利用自然排序实现排序

import java.util.Set;
import java.util.TreeSet;

/*实现Comparable接口进行排序*/
public class Person implements Comparable<Person>{

	String name;
	int id;
	
	/**
	 * 有参构造方法，初始化信息
	 * @param name
	 * @param id
	 */
	public Person(String name, int id) {
		this.name = name;
		this.id = id;
	}
	
	public static void main(String[] args) {
		TreeSet<Person> treset = new TreeSet<Person>();
		treset.add(new Person("张三", 12));
		treset.add(new Person("李四", 13));
		treset.add(new Person("王五", 14));
		treset.add(new Person("赵六", 15));
		System.out.println(treset);
	}
	
	@Override
	public int compareTo(Person o) {
		return id > o.id ? 1 : -1;
	}
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return name + "," + id;
	}
}

自定义排序：
如果年龄相同，就根据姓名来排序

public class Person implements Comparable<Person>{

	String name;
	int age;
	
	public Person(String name, int age) {
		// TODO Auto-generated constructor stub
		this.name = name;
		this.age = age;
	}
	
	public static void main(String[] args) {
		TreeSet<Person> treset = new TreeSet<>();
		treset.add(new Person("张三", 22));
		treset.add(new Person("李四", 22));
		treset.add(new Person("王五", 26));
		treset.add(new Person("赵六", 25));
		treset.add(new Person("冯七", 33));
		treset.add(new Person("A李四", 22));
		System.out.println(treset);
	}
	
	/**
	 * 自定义排序，现根据年龄进行排序，如果年龄相同，就根据姓名字典顺序来排序
	 */
	@Override
	public int compareTo(Person o) {
		// TODO Auto-generated method stub
		if (age != o.age) {
			return age > o.age ? 1 : -1;
		} else {
			return name.compareTo(o.name);
		}
	}
	
	/**
	 * 重写toString方法
	 */
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return name + "," + age;
	}
}

Map集合

Java.util.Map(K,V)接口用于存放键值对（Key => Value）形式的集合，其中键不允许重复，一个键只能对应一个值：
Map接口的常用实现类：
HashMap、TreeMap、LinkedHashMap和 Properties。

其中，HashMap是 Map 接口使用频率最高的实现类
HashMap，底层采用哈希表存储
TreeMap，底层采用红黑树存储
Map集合常用方法：put、get
增删改：
Object put(Object key,Object value)：将指定key-value添加 (或修改)当前map集合
void putAll(Map m):将m中的所有key-value对存放到当前map中
Object remove(Object key)：移除指定key的key-value对，并返回value
void clear()：清空当前map中的所有数据

查询操作：
boolean isEmpty() - 用于判断当前集合是否为空。
int size() - 用于获取当前集合中的键值对个数。
Object get(Object key)：获取指定key对应的value
boolean containsKey(Object key)：是否包含指定的key
boolean containsValue(Object value)：是否包含指定的value

元视图操作的方法：
Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet()：返回所有key-value（键值对）构成的Set集合/视图
K getKey() - 用于获取当前元素中的key值。
V getValue() - 用于获取当前元素中的value值。
代码演示：

TreeMap

TreeMap底层由红黑树实现，元素有序，类似与set集合中TreeSet，TreeSet底层极有可能由TreeMap实现。

HashMap

HashMap底层采用哈希表，元素无序，但HashMap键不可重复，
利用contains方法判断键是否重复

		Map<String, String> map = new HashMap<String, String>();
		map.put("1001", "张三");
		map.put("1002", "李四");
		map.put("1003", "王五");
		System.out.println(map);

由此代码可看出，Map键不可重复，如果重复，那就替换键所对应的值
HashMap的键就是Set集合中的实现类HashSet，HashSet底层实现就是Map，所以HashMap支持将键转换为HashSet。
利用迭代器遍历HashMap：

		Map<String, String> map = new HashMap<String, String>();
		map.put("1001", "张三");
		map.put("1002", "李四");
		map.put("1003", "王五");
		map.put("1002", "赵六");
		//根据键名找到对象的值
		System.out.println(map.get("1001"));
		
		//判断集合中是否包含键名1003
		System.out.println(map.containsKey("1003"));
		//entrySet()将map集合转换为set视图并返回
		//entry指的就是一个键值对，name=value这个整体成为一个键值对
		Set<Entry<String, String>> set = map.entrySet();
		//foreach循环遍历
		for (Entry<String, String> entry : set) {
			System.out.print(entry.getKey() + ",");
			System.out.println(entry.getValue());
		}
		//只获取map集合的键名
		Set<String> set2 = map.keySet();
		System.out.println(set2);
		for (String str : set2) {
			System.out.println(str);
			//map集合根据键名获取值
			System.out.println(map.get(str));
		}

ok，笔记到此结束，Java基础到此完结，博主会一直不断更的更新下一章节，制作不易，望多多支持，💕💕💕💕🤞🤞