JAVA中的常用API总结

1.数组Array

包含Arrays.sort(arr),数组排序，整型数组不可直接输出需要遍历后才可看到结果

Arrays.toString(arr),转为字符数组后就可以直接输出

Arrays.stream(arr).sum(),查看源码stream()API，

Arrays.stream(arr).max().getAsInt(),找数组中元素的最大值

Arrays.copyOfRange(arr,start,end),对数组进行切片遵循左闭右开

Arrays.equals(arr1,arr2),比较两个数组是否相等返回boolean类型

最后有数组的合并使用System.arraycopy(arr3,0,dd,0,arr3.length);可以查看源码arraycopy如下

public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

package com.qq.java.base;
import java.util.Arrays;
import java.util.List;
public class ArrayListApi {
	public static void main(String[] args) {
		int[] arr= {1,2,3,10,4,5};//定义一个整型数组
		int len=arr.length;// 数组求长度
		System.out.println(len);//输出数组的长度
		System.out.println("----------------");
		Arrays.sort(arr);//对数组进行排序
		for(int i=0;i<arr.length;i++) {
			System.out.println(arr[i]);
		}
		System.out.println("----------------");
		int sum=Arrays.stream(arr).sum();//使用Stream API求数组所有元素之和
		System.out.println(sum);
		System.out.println("----------------");
		int max=Arrays.stream(arr).max().getAsInt();//求数组所有元素最大值
		System.out.println(max);
		System.out.println("----------------");
		int[] test = Arrays.copyOfRange(arr,1,5);//对数组进行切片
		System.out.println(Arrays.toString(test));
		System.out.println("----------------");
		//toString() 可以放8中基本数据类型数组和对象数组，
		//返回指定数组的内容，是字符串类型
		String s=Arrays.toString(arr);
		System.out.println(s);
		System.out.println(arr[1]);
		System.out.println("----------------");
		//数组排序  int binarySearch()二分法排序，返回指定元素的索引值
		//注意：使用Ian需要将数组元素按从小大排序，否则可能返回错误值
		//使用多参二分法查找时，查找范围包括左边但不包括右边
		int index1=Arrays.binarySearch(arr, 10);
		System.out.println(index1);
		System.out.println("----------------");
		//数组equals boolean equals比较两个数组是否相同
		String[] arr3= {"白","其","其"};
		String[] arr4= {"白","其"," "};
		boolean re=Arrays.equals(arr3,arr4);
		System.out.println(re);
		System.out.println("----------------");
		//数组合并,使用System.arraycopy()方法
		String[] dd=new String[arr3.length+arr4.length];
		System.arraycopy(arr3,0,dd,0,arr3.length);
		System.arraycopy(arr4, 0, dd, arr3.length, arr4.length);
		System.out.println(Arrays.toString(dd));
	}	
}

2.字符串String

包含s.length（）获取字符串的长度，

s.charAt()给出索引对应的字符，

s.compareTo比较字符串的大小，

s.contains(another s)字符串包含是否包含另一种字符串

Integer.parseInt(s)字符串转整数

StringBuffer和StringBuilder是可变类，String是不可变的

可变的也就是可以动态的改变字符串中的值，添加，删除或插入等动态操作。

package com.qq.java.base;

public class StringApi {

	public static void main(String[] args) {
		// 求字符串的长度
		String s="hello java ";
		String s1="hello world java";
		String s2="hello";
		int len=s.length();//求字符串的长度
		//[begin,end)之间的字符串，如果只给了begin，则end默认到原字符串末尾
		String sub = s.substring(1,4);//结果ell
		char c=s.charAt(2);//取第index个字符
		int r=s.compareTo(s1);//r<0代表s<s1
		boolean b = s.contains(s2);//s是否包含子字符串s2
		String s3="123";
		int res=Integer.parseInt(s3);//字符串转整数
		System.out.println(len);
		System.out.println(sub);
		System.out.println(c);
		System.out.println(r);
		System.out.println(b);
		System.out.println(res);
		
		//StringBuilder中常用的函数方法
		/**
		 * StringBuffer和StringBuilder是可变类，String是不可变的
		 * StringBuffer是线程安全和同步的，而StringBuilder不是，所以StringBuffer比较快
		 * 字符串连接元素安抚（+）在内部使用String Builder类
		 * 对于非多线程环境中的字符串操作，我们应该使用StringBuilder而非StringBuffer类
		 */
		StringBuilder str=new StringBuilder();
		str.append("kIKi");
		System.out.println(str);
		str.insert(4, " "+s2);//在字符串的第5个位置插入s2
		System.out.println(str);
	}

}

3.List

List是位于java.util下的一个接口，有序集合（也称为序列）

它的实现类常用的有三种分别为：LinkedList、ArrayList和Vector

初始化：

LinkedList<Integer> linked=new LinkedList<>();

ArrayList<Integer> array=new ArrayList<>();

Vector<Integer> v=new Vector<>();

LinkedList采用双向链表实现的列表，适用于需要经常添加和删除的数据， ArrayList是采用数组实现的链表，因此它支持随机访问，不适合频繁删除和插入操作。

实现方法可以查看源码，以下是写了部分方法

package com.qq.java.base;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;

public class ListApi {

	public static void main(String[] args) {
		// List是一个接口，它的实现类常用的有LinkedList/ArrayList和Vector
		/**
		 * LinkedList采用双向链表实现的列表，因此可以被用作队列，堆栈，双端队列；
		 * 顺序访问高效，随机访问性能较差、适用于需要经常添加和删除的数据
		 * LinkedList不支持同步
		 *
		 */
		LinkedList<Integer> linked=new LinkedList<>();
		linked.add(1);//在链表末尾添加元素
		linked.add(2);
		linked.add(3);
		linked.add(4);
		System.out.println(linked);
		linked.addFirst(10);//在链表的首部添加元素
		System.out.println(linked);
		linked.add(1,12);//在所以1处添加元素（从0开始计),原先1处及之后元素后移一位
		System.out.println(linked);
		int len=linked.size();//获取链表的长度
		int i = linked.remove(1);//删除索引1处的元素，并返回该元素
		System.out.println(i);
		int i1=linked.get(1);//获取索引1处的元素
		System.out.println(i1);

		//Arraylist
		/**
		 * ArrayList是采用数组实现的链表，因此它支持随机访问，不适合频繁删除和插入操作。
		 * 经常进行查询的数据建议采用此结构
		 * ArrayList与java数组的一个大的区别是ArrayList能够自动扩容
		 * ArrayList不支持同步
		 * 
		 */
		ArrayList<Integer> array=new ArrayList<>();
		array.add(1);
		array.add(2);
		array.add(3);
		array.add(4);
		array.add(5);
		System.out.println(array);
		int length=array.size();//获取长度
		System.out.println(length);
		array.add(1,9);//在索引1（从0开始计）处添加元素9，原先1处及之后元素后移
		System.out.println(array);
		int ele=array.get(3);
		System.out.println(ele);
		
		
		//Vector和ArrayList用法类似
		Vector<Integer> v=new Vector<>();
		v.add(1);
		v.add(2);
		v.add(3);
		v.add(4);
		int length1=v.size();//获取长度
		System.out.println(length1);
		
		//List是一个接口，可以将LinkedList,ArrayList和Vector的对象赋给List变量
		//初始化
		List<Integer> list1=new LinkedList<>();
		List<Integer> list2=new ArrayList<>();
		List<Integer> list3=new Vector<>();
		//列表转数组
		list2.add(1);
		list2.add(2);
		list2.add(3);
		list2.add(4);
		System.out.println(list2);
		//利用java的stream
		int[] res=list2.stream().mapToInt(Integer::intValue).toArray();
		System.out.println(res);
		//也可以直接转为Integer数组
		Integer[] inte=list2.toArray(new Integer[list2.size()]);
		System.out.println(inte);
		
		String[] arr=(String[])list2.toArray(new String[list2.size()]);
		System.out.println(arr);
	}

}