Java数据类型一些常用的处理方法

一、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);