一、String
String s = “hello”;
获取字符串长度:
s.length();
连接字符串:
s = s + “!”;
or
s.concat(“!”);
返回索引的char值:
s.charAt(index);
当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真
s.contentEquals(StringBuffer ss);
测试此字符串是否以指定的后缀结束
s.endsWith(String suffix);
测试此字符串是否以指定的前缀开始
s.startsWith(String prefix);
将此 String 与另一个 String 比较,不考虑大小写
s.equalsIgnoreCase(String anotherString);
返回此字符串的哈希码
s.hashCode();
返回指定字符在此字符串中第一次出现处的索引
s.indexOf(int ch);
返回指定子字符串在此字符串中第一次出现处的索引
s.indexOf(String str);
返回指定字符在此字符串中最后一次出现处的索引
s.lastIndexOf(int ch);
根据给定正则表达式的匹配拆分此字符串
s.split(String regex);
将此字符串转换为一个新的字符数组
s.toCharArray();
使用默认语言环境的规则将此 String 中的所有字符都转换为小写
s.toLowerCase();
使用默认语言环境的规则将此 String 中的所有字符都转换为大写
s.toUpperCase();
返回此对象本身
s.toString();
返回字符串的副本,忽略前导空白和尾部空白
s.trim();
判断是否包含指定的字符系列
s.contains(Charsequence chars);
判断字符串是否为空
s.isEmpty();
二、StringBuffer和StringBuilder
StringBuffer sb = new StringBuffer();
将指定的字符串追加到此字符序列
sb.append(String s);
将此字符序列用其反转形式取代
sb.reverse();
移除此序列的子字符串中的字符
sb.delete(int start,int end);
将 str 参数的字符串插入此序列中
sb.insert(int offset,String str);
使用给定 String 中的字符替换此序列的子字符串中的字符
sb.replace(int start,int end,String str);
返回当前容量
sb.capacity();
返回此序列中指定索引处的 char 值
sb.charAt(int index);
返回第一次出现的指定子字符串在该字符串中的索引
sb.indexOf(String str);
返回最后出现的指定子字符串在此字符串中的索引
sb.lastIndexOf(String str);
返回长度
sb.length();
将给定索引处的字符设置为 ch
sb.setCharAt(int index,char ch);
返回此序列中数据的字符串表示形式
sb.toString();
三、数组
声明数组:
dataType[] arrayRefVar;
int[] a;
a = new int[arraySize];
数组长度
a.length;
Arrays类
用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。如果查找值包含在数组中,则返回搜索键的索引;否则返回-1;
public static int binarySearch(Object[] a,Object key);
如果两个指定的 基本数据类型 型数组彼此相等,则返回 true。
public static boolean equals(long[] a,long[] b);
将指定的 int 值分配给指定 int 型数组指定范围中的每个元素,同时适用于其它的基本数据类型;
public static void fill(int[] a,int val);
对指定对象数组根据其元素的自然顺序进行升序排列
public static void sort(Object[] a);
四、ArrayList
初始化:
ArrayList<E> objectName = new ArrayList<>();
ArrayList<String> al = new ArrayList<string>();
添加元素:
al.add(“1”);
访问元素:从0开始
al.get(index)
修改元素:
al.set(index,value);
删除元素:
al.remove(index);
集合大小:
s.size();
集合排序:
需要类 Collections
Collections.sort(al);
添加集合中的所有元素到 arraylist 中
al.addAll(Collection<? extends E>c);
删除 arraylist 中的所有元素
al.clear();
复制一份 arraylist
al.clone();
判断元素是否在 arraylist
al.contains(Object o);
返回 arraylist 中元素的索引值
al.indexOf(Object o);
删除存在于指定集合中的 arraylist 里的所有元素
al.removeAll();
判断 arraylist 是否为空
al.isEmpty();
返回此列表中指定元素最后一次出现的索引,如果此列表不包含该元素,则返回-1
al.lastIndexOf(Object o);
删除此列表中指定位置的元素
al.remove(int index);
从该列表中删除指定元素的第一个匹配项(如果存在)
al.remove(Object o);
从此列表中删除指定集合中包含的所有元素。
al.removeAll(Collection<?> c);
仅保留此列表中包含在指定集合中的元素。
al. retainAll(Collection<?> c);
从此列表中删除索引介于 fromIndex (含)和 toIndex (独占)之间的所有元素
al.removeRange(int fromIndex, int toIndex)
返回指定的 fromIndex (包含)和 toIndex (不包括)之间的此列表部分的视图。
al.subList(int fromIndex, int toIndex);
用指定的元素替换此列表中指定位置的元素
al.set(int index, E element)
以适当的顺序(从第一个元素到最后一个元素)返回包含此列表中所有元素的数组
al.toArray();
以适当的顺序返回包含此列表中所有元素的数组(从第一个元素到最后一个元素); 返回数组的运行时类型是指定数组的运行时类型
al.toArray(T[] a);
将此 ArrayList实例的容量调整为列表的当前大小
al.trimToSize();
五、LinkedList 链表
LinkedList 实现了 Queue 接口,可作为队列使用。
LinkedList 实现了 List 接口,可进行列表的相关操作。
LinkedList 实现了 Deque 接口,可作为队列使用。
LinkedList 实现了 Cloneable 接口,可实现克隆。
LinkedList<String> lol = new LinkedList<String>();
在列表开头添加元素
ll.add(String s);
头部插入元素,返回是否成功,成功为 true,失败为 false。
ll.offerFirst(E e);
在列表结尾添加元素
ll.addLast(String s);
向链表末尾添加元素,返回是否成功,成功为 true,失败为 false。
public boolean offer(E e);
列表开头移除元素
ll.removeFirst();
在列表结尾移除元素
ll.removeLast();
获取列表开头的元素
ll.getFirst();
获取列表结尾的元素
ll.getLast();
获取列表大小
ll.size();
向指定位置插入元素
public void add(int index, E element);
将一个集合的所有元素添加到链表后面,返回是否成功,成功为 true,失败为 false。
public boolean addAll(Collection c);
清空链表
ll.clear();
删除并返回第一个元素
public E removeFirst();
删除并返回最后一个元素
public E removeLast();
删除某一元素,返回是否成功,成功为 true,失败为 false。
public boolean remove(Object o);
删除指定位置的元素
public E remove(int index)
删除并返回第一个元素
public E poll();
判断是否含有某一元素
public boolean contains(Object o);
返回指定位置的元素
public E get(int index);
六、HashSet
HashSet<String> st = new HashSet<String>();
添加元素
st.add(“hello world!”);
判断元素是否存在
st.contains(“hello world!”);
删除元素
st.remove(“hello world!”);
删除集合中所有元素
st.clear();
计算大小
st.size();
七、HashMap
HashMap<Integer,String> hm = new HashMap<Integer,String>();
添加元素
hm.put(1,”hello world!”);
访问元素
使用 get(key) 方法来获取 key 对应的 value
hm.get(1);
删除元素
使用 remove(key) 方法来删除 key 对应的键值对(key-value)
hm.remove(1);
删除所有键值对
hm.clear();
计算大小
hm.size();
只想获取 key,可以使用 keySet() 方法
for(Integer i:hm.keySet()){
System.out.println(i);
}
返回 hashMap 中存在的所有 value 值
hm.values();
判断 hashMap 是否为空
hm.isEmpty();
替换 hashMap 中是指定的 key 对应的 value
hm.replace();
八、Stack
栈是Vector的一个子类
堆栈只定义了默认构造函数,用来创建一个空栈。 堆栈除了包括由Vector定义的所有方法,也定义了自己的一些方法
Stack<Integer> st = new Stack<Integer>();
测试堆栈是否为空
st.empty();
查看堆栈顶部的对象,但不从堆栈中移除它
st.peek();
移除堆栈顶部的对象,并作为此函数的值返回该对象
st.pop();
把项压入堆栈顶部
st.push(Object element);
返回对象在堆栈中的位置,以 1 为基数
st.saerch(Object element);