java study（常用的API第一部分）

第一节 Scanner类

1、API

      API（Application Programming Interface），应用程序编程接口。Java API是一本程序员的字典，是JDK中提供给我们使用类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。所以我们可以通过查询API的方式，来学习java提供的类，并得知如何使用它们。

2、API使用步骤

• 1.打开帮助文档
• 2.点击显示，找到索引，看到输入框
• 3.你要找谁？在输入框里输入，然后回车
• 4,看包。Java.lang下的类不需要导包，其他需要
• 5.看类的解释和说明
• 6.学习构造方法
• 7.使用成员方法

3、Scanne类

3.1什么是Scanner类

      一个可以解析基本类型和字符串的简单文本扫描器。

import java.util.Scanner;

public class Scanner1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int i = sc.nextInt();
        System.out.println(i);
    }
}

System.in 系统输入指的是通过键盘录入数据。

注意：引用类型的一般使用步骤

• 1.导包
  import 包路径.类名称；
  如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写
  只有java.lang包下的内容不需要导包，其他的包都需要import语句

  import java.util.Scanner;

• 2.创建
  类名称 对象名 = new 类名称();

  Scanner sc = new Scanner(System.in);

• 3.使用
  对象名.成员方法()
  int i = sc.nextInt();//获得整数
  String str = sc.next();//获得字符串

• 注意：键盘输入的都是字符串，只是相应的next方法将其转为对应的数据类型

import java.util.Scanner;

public class MAX {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入第一个数字：");
        int a = sc.nextInt();
        System.out.println("请输入第一个数字：");
        int b = sc.nextInt();
        System.out.println("请输入第一个数字：");
        int c = sc.nextInt();

        int tem = a > b ? a : b;
        int max = tem > c ? tem : c;
        System.out.println(max);
    }
}

第二节 匿名对象

1、匿名对象的创建

      创建对象的标准格式：
            类名称 对象名 = new 类名称();
      匿名对象就是只有右边的对象，没有左边的名字和赋值运算符
            new 类名称();

• 注意事项：匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象。
• 使用建议：如果确定又一个对象只需要使用唯一的一次，就可以用匿名对象。

2、匿名对象作为方法的参数

import java.util.Scanner;

public class Anonmous {
    public static void main(String[] args) {
        //普通使用方式
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();

        //匿名对象使用方式
        int a = new Scanner(System.in).nextInt();

        //使用一般方法传入参数
        Scanner sc1 = new Scanner(System.in);
        methonParam(sc1);
        //使用匿名对象来进行传参
        methonParam(new Scanner(System.in));
    }
    public static void methonParam(Scanner sc){
        int nem = sc.nextInt();
    }

    public static Scanner methidReturn(){
      return new Scanner(System.in);
    }

}

第三节 Random概述和基本使用

1、Random使用

      使用也是三个步骤
            1.导包
                  Import java.util.Random;
            2.创建
                  Random r = new Random();//小括号留空即可
            3.使用
                  获取一个随机的int数字（范围是int所有范围，有正负两种）:int num = r.nextInt()；

生成的是整个int范围的随机数

public class RandomInt {
    public static void main(String[] args) {
        Random r = new Random();
        System.out.println(r.nextInt());
    }
}

2、生成指定范围内的随机数

       r.nextInt(n) n:代表了范围，左闭右开 从0开始
      r.nextInt(3) 表示[0,3）

3、生成1-n之间的随机数

    思路：

• 1.定义一个int变量n，随意赋值
• 2.要使用Random：三个步骤，导包、创建、使用
• 3.如果要写10，那么就是0~ 9，然而想要的是1~10，可以发现：整体加1即可
• 4.打印随机数

import java.util.Random;
public class RandomInt {
    public static void main(String[] args) {
        Random r = new Random();
        System.out.println(r.nextInt());
        int n = 5;
        for (int i = 0; i < 10; i++) {
            System.out.println(r.nextInt(n)+1);
        }

    }
}

第四节 ArrayLIst集合

1、定义一个数组，用来存储三个Person对象。

    数组有一个缺点：一旦创建，程序运行期间长度不可以发生改变。

    

public class Demo01Array {
    public static void main(String[] args) {
        Person[] array = new Person[3];
        Person one = new Person("alex1",16);
        Person two = new Person("alex2",17);
        Person thress = new Person("alex3",18);
        //将one当中的地址值赋值到数组的0号元素位置
        array[0]=one;
        array[1]=two;
        array[2]=thress;
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);

        System.out.println(array[0].getName());
    }
}

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

2、ArrayList集合和基本使用

2.1 概述

    java.util.ArrayList是大小可变的数组的实现，存储在内的数据成为元素。此类提供一些方法来操作内部存储的元素。ArrayList中可不断添加元素，其大小也自动增长。

2.2 使用方式

• 数组的长度在程序运行的过程是不可以改变的，但是ArrayList集合的长度是可以随意变化的。
• 对于ArrayList来说，有一个尖括号代表泛型。
• 泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。
• 注意：泛型只能是引用类型，不能是基本数据类型

注意事项：
    对于ArrayList集合来说，直接打印得到的不是地址值，而是内容
    如果内容是空，得到的是空的中括号：[ ]

添加元素：list.add();

import java.util.ArrayList;
public class DemoArrayList {
    public static void main(String[] args) {
        //创建一个ArrayList集合，集合名称是list，里面装的全都是String字符串类型的数据
        //备注：从JDK 1.7+开始，右侧的尖括号可以不写内容，但是<>本身还是要写的
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);
        //向集合当中添加一些数据，需要用到add方法。
        list.add("2");
        list.add("2");
        list.add("2");
        System.out.println(list);
    }
}

2.3ArrayList集合的常用的方法

• 1.public boolean add(E e); 向集合当中添加元素，参数的类型和泛型一致、返回值代表添加是否成功。
  备注：对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用，但是对于其他集合（今后学习）来说，add添加动作不一定成功。
• 2.public E get(int index);从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。
• 3.public E remove(int index);从集合当中删除元素，参数是索引编号，返回值就是被删除的元素
• 4.public int size();获取集合的尺寸长度，返回值是集合中包含的元素个数。

//从集合中获取对应的元素：get。索引值从0开始
String num = list.get(1);
System.out.println("获取的第1号元素为："+num);
//从集合中删除元素，remove 索引值从0开始
String num1 = list.remove(1);
System.out.println("被删除的元素："+num1);
System.out.println(list);
//获取集合的长度尺寸，也就是其中元素的个数
int num2 = list.size();
System.out.println("长度为："+num2);

• 5.遍历

for (int i = 0; i < list.size(); i++) {
   	System.out.println(list.get(i));
}

2.4 ArrayList集合存储基本数据类型

    如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类”

基本类型                                包装类（引用类型，包装类都位于java.lang包下）
byte                                         Byte
short                                        Short
int                                            Integer [特殊记忆]
long                                        Long
float                                        Float
double                                    Double
char                                        Character [特殊记忆]
boolean                                    Boolean

• 注意：从JDK 1.5+开始，支持自动装箱、自动拆箱

自动装箱：基本类型 包装类型
自动拆箱：包装类型基本类型

ArrayList<Integer> intList = new ArrayList<>();
intList.add(100);
intList.add(200);
int n = intList.get(1);
System.out.println(n);

2.5 ArrayList当中方法的参数和当中方法的返回值

要求：用一个大集合存入10个随机数，然后筛选其中的偶数元素，放到小集合当中。要求使用自定义的方法来实现筛选

分析：

• 1.需要创建一个大集合，用来存储int数字：
• 2.随机数字就用Random nextInt()
• 3.循环10次，把随机数字放入到大集合：for循环、add方法
• 4.定义一个方法，用来进行筛选
• 筛选：根据大集合，筛选符合要求的元素，得到小集合

三要素：

• 返回值类型：ArrayList小集合（里面元素个数不确定）
  方法名称：getEven
• 参数列表：ArrayList大集合（装着10个随机数）

public class Demo02ArrayList {
    public static void main(String[] args) {
        Random rd = new Random();
        //rd.nextInt(100);
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add(rd.nextInt(100));
        }
        System.out.println(list);
        System.out.println("even's length is "+getEven(list).size()+getEven(list));
    }
    public static ArrayList<Integer> getEven(ArrayList<Integer> list){
        ArrayList<Integer> getEven = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i)%2==0){
                getEven.add(list.get(i));
            }
        }
        return getEven;
    }
}

第五节 String字符串

1、字符串的特点：

       字符串是常量：它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为String对象是不可变的，所以可以共享。

• 1.字符串的内容是永远不变的
• 2.正是因为字符串不可改变，所以字符串是可以共享使用的
• 3.字符串效果上相当于char[]字符数组，但是底层原理是byte[]字节数组

2、字符串的构造方法和直接创建

三种构造方法：
       public String():创建一个空白字符串，不含有任何内容

       public String(char[] array)：根据字符数组的内容，来创建对应的字符串

       public String(byte[] array)：根据节数组的内容，来创建对应的字符串

直接创建：String str = “hello”;//右边直接用双引号

• 注意：直接写上双引号，就是字符串对象

 public class Demo01String {
    public static void main(String[] args) {
        //使用空参构造
        String str1 = new String();//小括号留空，说明字符串什么内容都没有
        System.out.println(str1);   //输出为空

        //根据字符数组创建字符串
        char[] charArray = {'a','b','c'};
        String str2 = new String(charArray);
        System.out.println(str2);//输出：abc

        //根据字节数组创建字符串
        byte[] byteArray ={97,98,99};
        String str3 = new String(byteArray);
        System.out.println(str3);//输出：abc
    }
}

3、字符串的常量池

• 字符串常量池：程序当中直接写上的双引号，就在字符串常量池中
• 对于基本类型来说，== 是进行数值的比较
• 对于引用类型来说，==是进行地址值的比较

public class Demo02StringPool {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";
        char[] charArry = {'a','b','c'};
        String str3 = new String(charArry);

        System.out.println(str1==str2); //true
        System.out.println(str1==str3);//false
        System.out.println(str3==str2);//false
    }
}

分析：

• 1、对于String str1 = “abc”; String str2 = “abc”;首先会在堆中建立一个字符串常量池，然后将字符串的类型转为byte存储。同时将字符串对应的地址0x666返回给str1和str2
• 2、在char[] charArry = {‘a’,‘b’,‘c’};创建的时候，会在堆中建立
• 3、当执行String str3 = new String(charArry);时会将char[]类型装为byte类型，然后新建立一个字符串对象，并将其地址0x999返回给str3。

4、字符串的常用方法

4.1比较相关方法

      ==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法：
      1.public Boolean equals(object obj):参数可以是任何对象，只有参数是一个字符串并且内容相同的才会返回true，否则返回false。
注意：

• 1.任何对象都能用object进行接收。
• 2.equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。
• 3.如果比较双方一个常量一个变量，推荐把常量字符串写在前面。
  推荐"abc".equals(str1);不推荐str1.equals(“abc”);因为当str1为null的时候，后者会报错，前者返回的是false。

System.out.println(str1.equals(str2));
System.out.println(str2.equals(str3));
System.out.println(str1.equals(str3));
System.out.println(str1.equals("abc"));
System.out.println("abc".equals(str3));

• 4.public boolean euqalsIgnoreCase(String str)；忽略大小写，进行内容比较。

4.2 字符串的获取相关方法

• public int length();获取字符串当中含有的字符个数，拿到字符串的长度
• public String concat(String str);将当前字符串和参数字符串拼接成为返回值新的字符串。
• public char charAt(int index);获取指定索引位置的单个字符（索引从0开始）
• public int indexOf(String str);查找参数字符串在本字符串当中首次出现的索引文章，如果没有返回-1值。

4.3 字符串的截取方法

• public String substring(int index);截取从参数位置一直到字符串末尾，返回新字符串
• public String substring(int begin,int end);截取从begin开始，一直到end结束，中间的字符串
• 备注：[begin，end），包含左边，但是不包含右边

public class Demo03Substring {
    public static void main(String[] args) {
        String str1 = "helloworld";
        String str2 = str1.substring(2);
        System.out.println(str1);
        System.out.println(str2);
        

        //下面这种写法，字符串的内容仍然是没有改变的
        //下面有两个字符串："hello"  "java"
        //strA当中保存的是地址值
        //本来hello的地址值假设是0x666
        //后来地址值变成了java的0x999
        //本身字符串的内容没有改变
        String strA = "hello";
        System.out.println(strA);
        strA = "JAVA";
        System.out.println(strA);

    }
}

4.4 字符串的转换相关方法

• 1.public char[ ] toCharArray( );将当前字符串拆分成字符数组作为返回值
• 2.public byte[ ] getBytes();获得当前字符串底层的字节数组
• 3.public String replace(CharSequence oldString,CharSequence newString);将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。

public class Demo04StringConvert {
    public static void main(String[] args) {
        //转换为字符数组
        char[] chars = "hello".toCharArray();
        System.out.println(chars);

        char[] chars1 = {'a','b'};
        System.out.println(chars1);//char类型的数组会直接打印内容

        //转换成为字节数组
        byte[] bytes = "abc".getBytes();
        System.out.println(bytes);
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }

        String str = "how do you do";
        String str2 = str.replace('o','*');
        System.out.println(str2);
    }
}

4.5 字符串的分割

       分割字符串的方法：
            public String[] split(String regex)；按照参数的规则，将字符串切分成为若干部分。

注意事项：

• Split方法的参数其实是一个正则表达式，
• 如果要按照英文句号进行分割，必须写 \ \ .（两个反斜杠）

public class Demo04StringSplit {
    public static void main(String[] args) {
        String str1 = "aaa,bbb,ccc";
        String[] str2 = str1.split(",");
        for (int i = 0; i < str2.length; i++) {
            System.out.println(str2[i]);
        }
        System.out.println("==========");

        String str3 = "aaa.bbb.ccc";
        String[] str4 = str3.split("\\.");
        for (int i = 0; i < str4.length; i++) {
            System.out.println(str4[i]);
        }
    }
}

4.6 统计输入的字符串中各种字符的个数

思路：

• 1.既然用到了键盘输入，肯定是Scanner
• 2.键盘输入的是字符串，那么：String str = sc.next()
• 3.定义四个变量，分别代表四种字符各自的出现次数
• 4.需要对字符串一个字一个字的检查，String char[]，方法是toCharArray()
• 5.遍历char[]字符数组，对当前字符的种类进行判断，并且用四个变量进行++动作。
• 6.打印输出四个变量，分别代表四种字符出现次数
  注意：char类型在进行运算的时候，会提升为int类型

import java.util.Scanner;

public class Demo04StringCount {
    public static void main(String[] args) {
        System.out.println("请输入字符串：");
        Scanner sc = new Scanner(System.in);
        String str = sc.next();
        int countUpper = 0;
        int countLower = 0;
        int countOther = 0;
        int countNumber = 0;
        char[] chars = str.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            if('A' <= chars[i] && chars[i] <= 'Z'){
                countUpper++;
            }else if('a' <= chars[i] && chars[i] <= 'z'){
                countLower++;
            }
            else if('0' <= chars[i] && chars[i] <= '9'){
                countNumber++;
            }else{
                countOther++;
            }
        }
        System.out.println("大写字母："+countUpper);
        System.out.println("小写字母："+countLower);
        System.out.println("数字："+countNumber);
        System.out.println("其它："+countOther);


    }
}

第六节 静态static关键字

1、static

      一旦用了static关键字，那么这样的内容不再属于对象自己，而是属于类的，所以凡是本类的对象，都是共享同一份。

2、静态static关键字修饰成员变量

      如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类。多个对象共享同一份数据。

public class Student {
    private int id;//学号
    private String name;//姓名
    private int age;//年龄
    static String room;//所在教师
    private static int idCounter = 0;//学号计数器，每当new了一个新对象的时候，计数器++

    public Student( String name, int age) {
        this.id = ++idCounter;
        this.name = name;
        this.age = age;

    }

public Student() {
        this.id = ++idCounter;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Demo01Static {
    public static void main(String[] args) {
	Student.room = "101教室";
        Student one= new Student("郭靖",19);
        System.out.println("姓名:"+one.getName()+"年龄："+one.getAge()+"教室号"+ Student.room+"学号"+one.getId());
        Student two= new Student("黄蓉",18);
        System.out.println("姓名:"+two.getName()+"年龄："+two.getAge()+"教室号"+ Student.room+"学号"+two.getId());
    }
}

3、静态static关键字修饰成员方法

• 一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。
• 如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
• 如果有了static关键字，那么不需要创建对象，直接就能通过类名称使用它。
• 无论是成员变量还是成员方法，如果有了static，都推荐使用类名称进行调用。

静态变量：类名称.静态变量
静态方法：类名称.静态方法()

注意事项：

• 1.静态不能直接访问非静态，但是非静态可以访问静态
  原因：因为在内容中是先有的静太内容，后有的非静态内容（先人不知后人，后人知道先人）
• 2.静态方法当中不能用this
  原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。

public class MyClass {
    int num;
    static String name;
    public void method(){
        System.out.println("这是一个成员方法");
        System.out.println(num);
        System.out.println(name);
    }

   public static void methodStatic(){
       System.out.println("这是一个静态方法");
       System.out.println(name);
       //System.out.println(num);//错误，静态不能访问非静态
   }
}

public class Demoo2StaticMethod {
    public static void main(String[] args) {
        MyClass obj = new MyClass();//首先创建一个对象
        //然后才能使用没有static关键字的内容
        obj.method();
        //对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称调用
        MyClass.methodStatic();//正确，推荐
        obj.methodStatic();//正确，但是不推荐，这种写法在编译之后也会被javac翻译为“类名称.静态方法”

        myMthod();
        Demoo2StaticMethod.myMthod();
    }
    public static void myMthod(){
        System.out.println("自己的方法");
    }
}

4、静态static的内存图

      根据类名称访问静态成员变量的时候，全程和对象没有关系，只和类有关系。

分析：

• 1.在方法区中，会单独的存放一个静态区，所以static String room 在room赋值的时候回在方法区中的静态区存储。
• 2.当查找room的时候，会直接到方法区中查找（只和类有关系，和对象没有关系）

5、静态代码块

格式：
      public class 类名称{
            static{
                  //静态代码块
                  }
      }
      特点：

• 当第一次用到本类时，静态代码块执行唯一的一次。
• 静态内容总是优先于非静态，所以静态代码块比构造方法先执行。

静态代码块的典型用途：

• 用来一次性地对静态成员变量进行赋值

public class Person {
	//这是静态代码块
    static {
        System.out.println("静态代码块");
    }
	//这是构造函数
    public Person(){
        System.out.println("构造函数执行");
    }
}

public class Demo04Static {
    public static void main(String[] args) {
        Person one = new Person();
        Person two = new Person();
    }

}

结果：

第七节 Arrays工具

1、java.util.Arrays

      是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。

      public static String toString(数组)；将参数数组变成字符串（按照默认格式：[元素1，元素2，元素3…]）

      public static void sort(数组):按照默认升序（从小到大）对数组的元素进行排序

备注：

• 1.如果是数值，sort默认按照升序从小到大
• 2.如果是字符串，sort默认按照字母升序
• 3.如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparatpr接口的支持。（今后学习）

public class Demo01Arrays {
    public static void main(String[] args) {
        int[] intArray = {10,20,30};
        //将int[]数组按照默认格式变成字符串
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr);//[10,20,30]

        int[] array1 = {2,1,90,4,3,7};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));//[1, 2, 3, 4, 7, 90]

        String[] array2 = {"cbc","acb","bac"};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));//[acb, bac, cbc]

    }
}

2、请使用Arrays相关的API，将一个随机字符串中的所有字符升序排序，并倒序打印

public class ArraysTest {
    public static void main(String[] args) {
        //定义一个字符串
        String line = "sasfasdzxafdg";
        char[] chars = line.toCharArray();
        Arrays.sort(chars);
        for (int i = chars.length - 1; i >= 0; i--) {
            System.out.println(chars[i]);
        }
    }
}

第八节 数学工具类Math

1、java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作

• public static double abs(double num);获取绝对值，有多种重载
• public static double ceil(double num);向上取整
• public static double floor(double num);向下取整
• public static double round(double num);四舍五入

2、计算-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个

      分析：
            1.既然已经确定了范围，for循环
            2.起点位置-10.8应该装换为-10，两种方法：
                  2.1可以使用Math.ceil方法，向上（向正方向）取整
                  2.1强转成为int，自动舍弃所有小数位
            3.每一个数字都是整数，所以步进表达式应该是num++，这样每次都是+1的
            4.如何拿到绝对值：Math.abs方法
            5一旦发现了一个数字，需要让计数器++统计。

public class Demo02MathPractise {
    public static void main(String[] args) {
        int count = 0;//符合要求的数量
        double min = -10.8;
        double max = 5.9;
        //这样处理，变量i就是区间之间所有的整数
        for(int i = (int)min;i<max;i++){
            int abs = Math.abs(i);//绝对值
            if(abs>6||abs<2.1){
                count++;
                System.out.println(i);
            }
        }
        System.out.println("总共有："+count);
    }
}