Java 导包的使用

Scanner：输入

导包
import java.util.Scanner;

创建对象
	Scanner sc = new Scanner(System.in);

方法：
	int i = sc.nextInt(); //输入int类型

	String s = sc.nestLine(); //输入String类型

Random：生成随机数

导包
import java.util.Random;

创建对象
	Random r = new Random();//构造

方法：
	int i = r.Random(10); //0-9的随机数

Arrays

创建对象
	int[] arr = {1, 2, 3};

	int[] arr = new int[];
	arr[0] = 1;
	arr[1] = 2;
	arr[2] = 3;

	int[] arr = new int[] {1, 2, 3};

	int arr[] = {1, 2, 3};

	int arr[] = new int[3];
	arr[0] = 1;
	arr[1] = 2;
	arr[2] = 3;

	int arr[] = new int[] {1, 2, 3};

方法：
    int i = arr.length; //获得arr数组的长度

导包：
    import java.util.Arrays;

复制数组
	public static int[] copyOf(int[] original, int newLength)
        original：数组名     newLength：新数组的长度
填充数组
  public static void fill(int[] a, int val)
    a：数组名	val：要填充的数
数组排序
	public static void sort(int[] a)
    a:数组名 	新数组返回到数组本身
查找元素
	public static int binarySearch(int[] a, int key)
        a：数组名	key：要查找的元素

String

创建对象：
    String s = ""; //创建一个空的String类型
	String s = new String(); //创建一个空的String类型
    
	char[] chs = {'a', 'b', 'c'};
	String s = new String(chs);

	char[] chs = {'a', 'b', 'c'};
	String s = new String(chs,1,3); //1：是偏移量 3：字符长度

	byte[] bys = {97, 98, 99};
	String s - new String(bys);

	String s = "abc";

方法：
	int i = s.length(); //获得s的长度

	char ch = s.charAt(i); //获得s索引值为i的值

	boolean b = s.equals(s1); //判断s和s1是否相同，简单的==只是判断地址值

String Builder

构造方法：
	StringBuilder sb = new StringBuilder();

	StringBuilder sb = new StringBuilder("hello");

	String s = "hello";
	StringBuilder sb = new StringBuilder(s);

方法：
    int i = sb.length();

	sb.append("hello"); //在sb后面加一个hello，并且返回到对象本身
	sb.append(10); //sb后面什么都可以加
	sb.append("hello").append(10); //链式编程
	//因为返回到对象本身的性质，所以可以把前面的看做一个个的对象

	sb.reverse(); //反转sb的值

StringBuilder 转 String
    StringBuilder sb = new StringBuilder("hello");
	String s = sb.toString(); //toString() 方法的使用

String 转 StringBuilder
    String s = "hello";
	StringBuilder sb = new StringBuilder(s); //创建对象的时候赋值

ArrayList 集合

导包
import java.util.ArrayList;

创建对象
    ArrayList<String> array = new ArrayList<String>();

方法
    array.add("hello"); //在后面添加hello，要注意添加的类型和 <> 中间定义的类型要一致
	array.add(1, "hello"); //在索引值为1的地方加一个hello，原来的元素向后移

	array.remove.("hello"); //去除含有hello的元素，有多个重名时只能删除最前面的一个
	array.remove(1); //删除索引值为1的元素,返回值时布尔型，就是看他有没有删除成功

	array.set(1, "hello"); //将索引值为1的元素改成hello，返回值为被修改的元素

	array.size(); // 返回值为元素的个数


    ArrayList<Student> array = new ArrayList<Student>(); //自己创建的类，也是可以用的，但是个人认为他保存的就是指向(就是指针，但是Java中没有指针)
    Student s1 = new Student();
    Student s2 = new Student();
    array.add(s1).add(s2);

复制数组
	public static int[] copyOf(int[] original, int newLength)
填充数组
  public static void fill(int[] a, int val)
数组排序
	public static void sort(int[] a)
查找元素
	public static int binarySearch(int[] a, int key)

---

我自己对API文档的感觉：

如果该类有构造方法就要先构造，即

类名 对象名 = new 类目(); //具体的看构造的方法

使用该类的方法，即

对象名.方法名(); //具体的还要看方法的介绍

没有构造方法的（方法被static修饰的）

调用该类的方法时，即

类名.方法名();

使用static 修饰的方法和变量是类变量和类方法！在jdk 将类编译完以后，java 会用类加载器将类加载进内存中！然后才可以让我们去运行，
类变量和类方法就是在这个时候实例化了，它的生命周期也是跟随着类，随它产生而产生，随它死亡而死亡。因此它的调用方式也与平常变量，方法不一样，普通方法是在new 一个类时才开始 出世（也就是生命周期的开始）。所以普通方法需要new 一个类后，再用这个类的实例来调用。而静态方法可以直接用 类名.方法 进行调用。（因为他在产生的时候就已经产生无须实例化类也可以调用）

---