Java学习笔记之常用类

1 ArrayList 、LinkedList

//[注]两者操作基本一致

//创建集合
//一般不写 ArrayList list = new ArrayList();
//直接使用其父类 List，方便修改类型时直接改为 List list = new LinkedList();
List list = new ArrayList();		//顺序表
List list = new LinkedList();		//链表

//直接添加元素到集合末尾			
list.add(num1);
list.add(num2);			

//添加 num 到数组的 index 索引处
list.add(index, num);		

//添加集合到集合末尾
List s1 = new ArrayList();
list.addAll(s1);		

//添加集合到指定位置 index
list.addAll(index, s1);		

//获取集合大小
list.size();		

//获取指定下标 index 的元素
list.get(index)				
    
//获取指定元素 num 在集合中首次出现时对应的下标
list.indexOf(num);		

//集合判空
list.isEmpty();

//判断集合是否包含 num 元素
list.contains(num);

//清空集合
list.clear();

//判断两个集合是否相等
list.equals(s1);

//返回此集合的哈希值
list.hashCode();

//将集合转化为一个迭代器
list.iterator();

//将集合转为一个数组
list.toArray();

//移除集合指定索引 index 的元素
list.remove(index);

//返回指定范围内的元素，区间范围左闭右开 [leftIndex, rightIndex)
list.subList(leftIndex, rightIndex);

2 Arrays

//判断两个数组是否相同
Arrays.equals(list1, list2);

//返回数组的哈希值
Arrays.hashCode(list);

//将数组转为 ArrayList 类型
Arrays.asList(list);

//对数组进行排序（非递减）
Arrays.sort(list);

//在数组中二分查找指定元素 num
Arrays.binarySearch(list, num);

//复制数组所有元素到一个新的长度为 length 的数组中
Arrays.copyOf(list, length);

//复制数组指定范围内 [indexLeft, indexRight) 元素到新的数组中
Arrays.copyOfRange(list, indexLeft, indexRight);

//将数组使用元素 num 填满
Arrays.fill(list, num);

3 Queue

//创建队列
Queue<Integer> queue = new LinkedList<Integer>(); 	//继承自 Collection

//队列判空
queue.isEmpty();

//入队
queue.add(num);					//失败会抛出异常
queue.offer(num);				//失败会返回 null

//出队
queue.remove();					//失败会抛出异常

//取队头元素
queue.element();				//返回第一个元素
queue.peek();					//返回第一个元素
queue.poll();					//返回第一个元素，并且删除

4 Stack

//创建栈
Stack stack = new Stack();

//栈判空
stack.isEmpty();

//入栈
stack.push(num);

//出栈
stack.pop();					//失败抛出异常

//取栈顶元素
stack.elements();				//失败返回 null
stack.peek();					//失败抛出异常

5 HashMap、Hashtable

/*
HashMap 与 Hashtable 区别：
	1 HashMap 的 key 或 value 可以为 null
	2 Hashatble 的 key 或 value 不能为 null
	3 其余操作两者均相同
*/


//创建哈希表
HashMap<keyType, valueType> hashMap = new HashMap<keyType, valueType>();

//添加键值对
hashMap.put(key, value);

//根据 key 获取对应的 value
hashMap.get(key);			//成功返回对应的 value，失败返回 null

//获取哈希表大小
hashMap.size();

//哈希表判空
hashMap.isEmpty();

//清空哈希表
hashMap.clear();

//克隆哈希表
hashMap.clone();			//返回一个浅拷贝的哈希表实例

//查询哈希表中是否包含指定 key
hashMap.containsKey(key)
    
//查询哈希表中是否包含指定 value
hashMap.containsValue(value)

//移除哈希表中的元素（key, value）同时移除，两种方式效果相同
hashMap.remove(key);
hashMap.remove(key, value);

//替换指定的 key 对应的 value 值，两种方式效果相同
hashMap.replace(key, newValue);
hashMap.replace(key, oldValue, newValue);

//查询某 key,若该 key 无对应的 value,则将其 value 设置为 defaultValue
hashMap.getOrDefault(key, defaultValue);

//返回哈希表的所有 key
hashMap.keySet();

//返回哈希表的所有 value
hashMap.values();

//比较两个哈希表是否相等
hashMap.equals(hashMap2);

6 HashSet

/*
HashSet 与 HashMap 区别：
	1 HashSet 只有 key，且 key 不存在重复
	2 HashMap 既有 key，也有 value, 且 (key, value) 不存在重复
*/

//创建哈希表
HashSet<keyType> hashSet = new HashSet<keyType>();

//添加元素
hashSet.add(key);

//删除元素
hashSet.remove(key);		//删除成功返回 true, 失败返回 false

//查找指定的 key
hashSet.contains(key);

//获取哈希表大小
hashSet.size();

//哈希表判空
hashSet.isEmpty();

//清空哈希表
hashSet.clear();

7 String

//创建字符串
String string = "someThing";

//查看字符串是否包含某字符或子串
string.contains(ch);				//查看字符 ch 是否在字符串中
string.contains(subStr);			//查看子串 subStr 是否在字符串中

//返回字符或子串在字符串中首次出现的位置索引
string.indexOf(ch);				//返回字符 ch 在字符串中首次出现的位置索引
string.indexOf(subStr);				//返回子串 subStr 在字符串中首次出现的位置索引
string.indexOf(ch, index);			//返回字符 ch 在字符串中首次出现的位置距离 index 的距离
string.indexOf(subStr, index);			//返回子串 subStr 在字符串中首次出现的位置距离 index 的距离

//返回字符或子串最后出现的位置
string.lastIndexOf(ch);				//返回字符 ch 最后出现的位置
string.lastIndexOf(subStr);			//返回子串 subStr 最后出现的位置

//字符或子串的替换
string = string.replace(oldChar, newChar);	//将字符串中所有的 oldChar 替换为 newChar
string = string.replace(oldStr, newStr);	//将字符串中所有的 oldStr 替换为 newStr

//字符串判空
string.isEmpty();

//字符串哈希值
string.hashCode();

//返回指定位置 index 的字符
string.charAt(index)
    
//返回指定索引 index 位置的字符的前后字符 Unicode 值
string.codePointAt(index);			//index 位置的字符对应的 Unicode 值
string.codePointBefore(index);			//index 位置前一字符对应的 Unicode 值
string.codePointCount(beginIndex, endIndex);	//返回字符串中 beginIndex 与 endIndex 之间相差的字符数量

//字符串比较
string.compareTo(string2);		//从前向后找对应位置不同的字符，返回 Unicode 差值,区分大小写
string.compareToIgnoreCase(string2);	//从前向后找对应位置不同的字符，返回 Unicode 差值，不区分大小写

//连接两个字符串
string.concat(string2);

//比较两个字符串是否相等
string.contentEquals(string2);
string.equals(string2);

//是否以固定字符或子串开头
string.startsWith(ch);			//是否以字符 ch 开头
string.startsWith(subStr);		//是否以子串 subStr 开头

//是否以固定字符或子串结尾
string.endsWith(ch);			//是否以字符 ch 结尾
string.endsWith(subStr);		//是否以子串 subStr 结尾

//全部转小写
string.toLowerCase(); 

//全部转大写
string.toUpperCase();  

//按照某字符或者子串分割字符串为一个字符串数组
string.split(ch);			//按照字符 ch 分割字符串为字符串数组
string.split(subStr);			//按照子串 subStr 分割字符串为字符串数组

//返回字符串的长度
string.length();

//返回执行索引范围内的字符串，范围区间为左闭右开 [leftIndex, rightIndex)
string.substring(leftIndex, rightIndex);