11:Java常用的类

1：Scanner类

一个可以解析基本类型和字符串的简单文本扫描器。
例如：以下代码使用户能够从System.in读取一个数。
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
备注:System.in系统输入指的键盘录入数据。

代码:

/*
Scanner类的功能：可以实现键盘输入数据，到程序当中。
引用类型的一般使用步骤:
1.导包
import 包路径.类名称;
如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句。
只有java.lang包下的内容不需要导包,其它的包都需要import语句。
2：创建
类名称 对象名 = new 类名称;

3:使用
对象名.成员方法名();
*/
import  java.util.Scanner;//获取键盘输入的int数字:sc.nextInt();
public class DemO1Scanner {//获取键盘输入的字符串 sc.next();
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //获取键盘输入的int数字
        int num = sc.nextInt();
        System.out.println("输入的数字" + num);
        //获取键盘输入的字符串
        String str = sc.next();
        System.out.println("输入的字符串"+ str);
    }
}

代码:键盘输入两个int数字,并且求出和值

import java.util.Scanner;

/*
题目:键盘输入两个int数字,并且求出和值。
思路:
1:既然需要键盘输入,那么就用Scanner
2:Scanner的三个步骤:导包,创建,使用
3:得到的是两个数字,所以调用两次nextInt方法
4:得到了两个数字,就需要加在一起
5:将结果打印输出
*/
public class Demo02ScannerSum {
    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();
        int result =a + b;
        System.out.println("a+b的和为:"+ result);
    }
}

2:匿名对象:

/*
创建对象的标准格式:
类名称 对象名 = new 类名称();

匿名对象就是只有右边的对象,没有左边的名字和赋值运算符。
new 类名称();

//注意事项:匿名对象只能使用唯一的一次,下次再用不得不再创建一个对象。
使用建议:如果确定有一个对象只需要使用唯一的一次,就可以用匿名对象。
*/
public class Demo01Anonymous {
    public static void main(String[] args) {
        //左边的one就是对象的名字
        DemO1Scanner one = new DemO1Scanner();
        //匿名对象
        new DemO1Scanner();
    }
}

3:Random类

import java.util.Random;

/*
Random类用来生成随机数字,使用起来也是三个步骤:
1:导包
import java.util.Random；
2:创建
Random r = new Random();//小括号当中留空即可。
3:使用
获取一个随机的int数字(范围是int所有范围,有正负两种): int num = r.nextInt();
获取一个随机的int数字（参数代表范围,左闭右开);int num = r.nextInt(3);实际上代表的含义是:[0,3),也就是0 1 2
*/
public class Demo03Random {
    public static void main(String[] args) {
        Random r = new Random();
        int num = r.nextInt();
        System.out.println("随机数字是:"+ num);
        for (int i = 0; i < 100; i++) {
            int num1 = r.nextInt(10);
            System.out.print(num1+"    ");

        }
    }
}

代码；

import java.util.Random;
import java.util.Scanner;

/*
题目:
用代码模拟猜数字的小游戏
思路:
1:首先需要产生一个随机数字,并且一旦产生不再变化。用Random的nextInt方法.
2:需要键盘输入,所以用到了Scanner
3:获取键盘输入的数字，用Scanner当中的nextInt方法
4：已经得到了两个数字，判断(if）一下
    如果太大，提示太大，并且重试
    如果太小，提示太小，平且重试
    如果猜中，游戏结束。
5:重试就是再来一次，循环次数不确定，用到while(true);
*/
public class Demo03Random {
    public static void main(String[] args) {
        Random r = new Random();
        int randomNum = r.nextInt(100)+1;//[1 ,100];
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("请输入你猜测的数字:");
            int guessNum = sc.nextInt();//键盘输入你猜测的数字。
            if(guessNum > randomNum){
                System.out.println("太大了，请重试");
            }else if(guessNum < randomNum){
                System.out.println("太小了，请重试");
            }else{
                System.out.println("恭喜你，猜中啦");
                break;//
            }
        }
        System.out.println("游戏结束。");
    }
}

4:ArrayList集合

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

查看类:
java.util.ArrayList<E>:该类需要import导入使用后使用。
<E>,表示一种指定的数据类型，叫做泛型.E,取自Element（元素)的首字母。在出现E的地方,我们使用一种引用数据类型将其替换即可,表示我们将存储哪种引用类型的元素。代码如下:
1: ArrayList<String>   ,ArrayList<Student>
查看构造方法:
public ArrayList()://构造一个内容为空的集合。
基本格式:
ArrayList<String> list = new ArrayList<String>();
在JDK7后,右侧泛型的尖括号之内可以留空,但是<>依然要写.简化格式;

代码;

import java.util.ArrayList;

/*
数组的长度不可以发生变化。
但是ArrayList集合的长度是可以随意变化的。

对于ArrayList来说，有一个尖括号<E>代表泛型
泛型：也就是在集合当中的所有元素，全部是什么类型。
泛型只能是引用数据类型，不能是基本数据类型。
*/
public class DemoArrayList01 {
    public static void main(String[] args) {
        //创建了一个ArrayList集合,集合的名称是list，里面装的全部都是String字符串类的数据。
        //备注：从JDK1.7+开始,右侧的尖括号内部可以不写内容,但是<>本身还是要要写的。
        //对于ArrayList集合来说,直接打印得到的不是地址值,而是内容。
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);
        //向集合当中添加一些数据，需要用到add方法。
        list.add("小明");
        list.add("小红");
        System.out.println(list);
    }
}

代码:ArrayList当中的常用方法

import java.util.ArrayList;

/*
ArrayList当中的常用方法有:
public boolean add(E e);//向集合当中添加元素,参数的类型和泛型一致。
备注:对于ArrayList集合来说,add添加动作一定是成功的,所以返回值可用可不用。
但对于其它集合来说,add添加动作不一定成功，返回值代表是否成功。
public E get(int index);//从集合当中获取元素,参数是索引编号。索引值从0开始。
public E remove(int index);//从集合当中删除元素,参数为索引编号，返回值就是被删除的元素。
public int size();//获取集合的尺寸长度，返回值是集合中包含的元素个数。
*/
public class DemoArrayList01 {
    public static void main(String[] args) {
      ArrayList<String> list = new ArrayList<>();
        System.out.println(list);
        //向集合中添加元素：add
        boolean success = list.add("小明");
        list.add("one");
        list.add("小红");
        System.out.println(list);
        System.out.println("添加的动作是否成功" + success);
        System.out.println("删除元素");
        String whoRemoved = list.remove(1);
        System.out.println(whoRemoved);
        System.out.println(list);
        int size = list.size();
        System.out.println("集合的长度"+size);
        for (int i= 0;i<list.size();i++){
            System.out.println(list.get(i));
        }
    }
}

代码:向集合ArrayList当中存储基本数据类型 0

import java.util.ArrayList;

/*
如果希望向集合ArrayList当中存储基本数据类型，必须使用基本数据类型对应的"包装类"。
基本类型  包装类(引用类型，包装类都位于java.lang包下）
byte       Byte
short      Short
int        Integer   【特殊】
long       Long
float      Float
double     Double
char       Character   【特殊】
boolean   Booleean

从JDK1.5开始，支持自动装箱，自动拆箱。
自动装箱：基本类型---->包装类型
自动拆箱：包装类型---->基本类型
* */
public class DemoArrayListBasic {
    public static void main(String[] args) {
        ArrayList<String> listA = new ArrayList<>();
        //错误写法!泛型只能是引用数据类型,不能是基本数据类型。
        //ArrayList<int> listB = new ArrayList<>();
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1000);
        list.add(200);
        list.add(222);
        for(int i =0 ;i<list.size();i++){
            System.out.println(list.get(i));
        }
    }
}

代码:生成6个1-33之间的随机整数，添加到集合,并遍历集合

import java.util.ArrayList;
import java.util.Random;

/*
题目:
生成6个1-33之间的随机整数，添加到集合,并遍历集合。

思路:
1.需要存储6个数字，创建一个集合，<Integer>
2.产生随机数，需要用到Random
3.用到循环6次，来产生6个随机数字：for循环。
4.循环内调用r.nextInt(int n),参数。33，0-32  整体+1才是1-33。
*/
public class Dem01ArrayListRandom {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Random r = new Random();
        for(int i= 0 ;i< 6;i++){
            int num = r.nextInt(33)+1;
            list.add(num);
        }
        //遍历集合
        for(int i =0 ;i<list.size();i++){
            System.out.println(list.get(i));
        }
    }
}

代码；定义以指定格式打印集合的方法

import javax.jws.soap.SOAPBinding;
import java.util.ArrayList;

/*
题目:
定义以指定格式打印集合的方法(ArrayList类型作为参数),使用{}括起来，使用@分隔每个元素
格式参照：{元素@元素@元素}
*/
public class Demo03ArrayListPrint {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("宋远桥");
        list.add("张无忌");
        list.add("张翠山");
        System.out.println(list);//[张三丰，宋远桥，张无忌，张翠山]
        printArrayList(list);
    }
    /*
    定义方法的三要素：
    返回值类型：只是进行打印而已，没有运算，没有结果，所以用void
    方法名称:printArrayList
    参数列表:ArrayList
    */
    public static void printArrayList(ArrayList<String> list){
        System.out.print("[");
        for(int i = 0;i<list.size();i++){
            String name = list.get(i);
            if(i == list.size()-1){
                System.out.print(name+"]");
            }else{
                System.out.print(name + "@");
            }
        }
    }
}

5:String类

/*
java.lang.String类代表字符串。
API当中说，java程序中所有的字符串字面值(如加"abc")都作为此类的实例实现。
其实就是说:程序当中的所有双引号字符串，都是String类的对象。（就没有new，也照样是。）
字符串的特点:
1:字符串的内容永不可变。
2:正是因为字符串不可改变，所以字符串是可以共享的。
3:字符串效果上相当于chan[]字符数组，但是底层原理是byte[]字节数组。

创建字符串的常见的3+1种方式：
三种构造方法:
public String();创建一个空白字符串,不含任何内容。
public String(char[] array); 根据字符数组的内容，来创建对应的字符串。
public String(byte[] array); 根据字节数组的内容，来创建对应的字符串。
一种直接创建：
注意:直接写上双引号，就是字符串。
*/
public class New01String {
    public static void main(String[] args) {
        //空参构造
        String st1 = new String();//小括号，说明字符串什么内容都没有。
        System.out.println("第1个字符串"+st1);

        //根据字符数组来创建字符串。
        char[] charArray ={'A','B','C'};
        String str2 =new String(charArray);
        System.out.println("第二个字符串"+str2);

        //根据字节数组来创建字符串
        byte[] byteArray = {97,98,99};
        String str3 = new String(byteArray);
        System.out.println("第3个字符串"+ str3);

        //直接创建
        String str ="hello";
    }
}

String常量池

/*
字符串常量池:程序当中直接写上的双引号字符串，就在字符串常量池中。

对于基本类型来说  ==是进行数值的比较。
对于引用类型来说，==是进行地址值的比较。
*/
public class Demo01StringPool {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";
        char[] charArray = {'a','b','c'};
        String str3 = new String(charArray);
        System.out.println(str1 == str2);
        System.out.println(str1 == str3);
        System.out.println(str2 == str3);
    }
}

字符串的比较

/*
==是进行对象的地址值比较，如果确实需要字符串的内容的比较，可以使用两个方法：
public boolean equals(object obj);参数可以是任何对象，只有参数是一个字符出并且内容相同的才会给true,否则是一个false.

public boolean equalsIgnorCase(String str)   //忽略大小写，进行内容的比较。
备注:
1;任何对象都能用object接收
2:equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。
3:如何比较双方一个常量一个变量。推荐把常量字符串写在2前面。
推荐:"abc".equals(str)   不推荐   str.equqls("ac");
*/
public class Demo01StringPool {
    public static void main(String[] args) {
      String str1 = "hello";
      String str2 = "hello";
      char [] charArray ={'h','e','l','l','o'};
      String str3 = new String(charArray);
        System.out.println(str1.equals(str2));//true
        System.out.println(str2.equals(str3));//true
        System.out.println(str3.equals("hello"));//true
        System.out.println("hello".equals(str1));
        String str4 = "Hello";
        System.out.println(str1.equals(str4));
        String str5 = null;
        System.out.println("abc1".equals(str5));//推荐 false
       // System.out.println(str5.equals("abc"));  //不推荐  ，报错 ，空指针异常。NullPointerException
        String strA = "JAVA";
        String strB = "java";
        System.out.println(strA.equals(strB));
        System.out.println(strB.equalsIgnoreCase(strA));
    }
}

字符串获取的相关方法

/*
String当中与获取相关的常用方法有
public int length()//获取字符串当中含有的字符个数，拿到的字符串的长度。
public String concat(String str)  //将当前字符串和参数字符串拼接成为返回值新的字符串。
public char charAt(int index)  //获取指定索引位置的单个字符。（索引从0开始）
public int indexOf(String str)    //查找参数字符串在本字符串首次出现的索引位置，如果没有，返回-1.
*/
public class Demo02St4ingGet {
    public static void main(String[] args) {
        //获取字符串的长度
        int length = "aaaaaaaaaaaaaaaaaaaaaaaaaa".length();
        System.out.println("字符串的长度是:"+ length);
        //拼接字符串
        String str1 ="Hello";
        String str2 = "World";
        String str3 = str1.concat(str2);
        System.out.println(str1);//Hello原封不动
        System.out.println(str2);//World原封不动
        System.out.println(str3);//HelloWorld 新的字符串。
        
        //获取指定索引位置的单个字符
        char ch = "Hello".charAt(1);
        System.out.println("在1号索引位置的字符是:"+ ch);
        System.out.println("=======================");
        //查找参数字符串在本来字符串当中出现的第一次索引位置。
        //如果没有，返回-1
        String original = "helloWorld";
        int index = original.indexOf("llo");
        System.out.println("第一次索引值是:"+ index);
    }
}

字符串的截取方法

/*
字符串的截取方法
public Strin  g substring(int index);  //截取从参数位置一直到字符串末尾，返回新字符串
public String substring(int begin,int end);//截取从begin开始，一直到end结束，中间的字符串
备注:[begin,end) ,包含左边，不包含右边。
*/
public class Demo02St4ingGet {
    public static void main(String[] args) {
        String str1 = "HelloWorld";
        String str2 = str1.substring(5);
        System.out.println(str1);//HelloWorld ,原封不动
        System.out.println(str2);//World ,新字符串
        System.out.println("===========================");
        String str3 = str1.substring(4,7);
        System.out.println(str3);//oWo
        System.out.println("======================");
        //下面这种写法，字符串的内容依然是没有改变的
        //下面有两个字符串： "Hello" ,"Java"
        //strA当中保存的是地址值
        //本来地址值是Hello的0x666
        //后面地址值变成Java的0x999
        String strA = "Hello";
        System.out.println(strA);//Hello
        strA ="Java";
        System.out.println(strA);//Java
    }
}

字符串的转换相关方法

/*
String当中与转换相关的常用方法有:
public char[] toCharArray(),将当前字符串拆分成字符数组作为返回值。
public byte[] getBytes();   //获得当前字符串底层的字节数组
public Sting replace(CharSequence oldString,CharSequence newString)//将所有出现的老字符串替换成新的字符串，返回替换之后的结果新字符串。
备注:CharSequence意思就是说可以接收字符串类型
*/
public class Demo01StringConvert {
    public static void main(String[] args) {
       //转换成为字符数组
       char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]);//H
        System.out.println(chars.length);//5
        System.out.println("====================");

        //转换成为字节数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }
        System.out.println("==========================");
        String str1 = "How do you do";
        String str2 = str1.replace("o","*");
        System.out.println(str1);
        System.out.println(str2);
    }
}

字符串的分割方法

/*
分割字符串的方法：
public String[] spilt(String reqx);按照参数的规则，将字符串切分成为若干部分
注意事项:
spilt方法的参数其实是一个"正则表达式" 
注意,如果按照英文句号'.'进行切分，必须写"\\.'
*/
public class Demo01StringSpilt {
    public static void main(String[] args) {
        String str1 = "aaa,bbb,ccc";
        String[] array1 =str1.split(",");
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }
        System.out.println("=========================");
        String str2 ="aaa bbb ccc";
        String[] array2 = str2.split(" ");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }
        System.out.println("=========================");
    }
}

题目：定义 一个方法，把数组{1,2,3}按照指定格式拼接成为一个字符串。格式如下：{word1#word2#word3}.

/*
题目：定义 一个方法，把数组{1,2,3}按照指定格式拼接成为一个字符串。格式如下：{word1#word2#word3}.
分析：
1.首先准备一个int[]数组，内容是:1，2，3
2：定义一个方法，用来将数组变成字符串
三要素
返回值类型：String
方法名称：fromArrayToString
参数列表:int[]
3:格式： {word1#word2word3}
用到:for循环，字符串拼接，每个数组元素之前都有一个word字样，分隔使用的是#，区分一下是不是最后一个
4.调用方法，得到返回值，并打印结果字符串
*/
public class Demo06StringPractice {
    public static void main(String[] args) {
        int[] array ={1,2,3};
        String result = fromArrayToString(array);
        System.out.println(result);
    }
    public  static String fromArrayToString(int[] array){
        String str ="[";
        for (int i = 0; i < array.length; i++) {
            if(i==array.length-1){
                str+="word" + array[i]+"]";
            }else{
                str+="word" + array[i]+ "#";
            }
        }
        return str;

    }
}

键盘输入一个字符串，并且统计其中各种字符出现的次数

import java.util.Scanner;

/*
题目；
键盘输入一个字符串，并且统计其中各种字符出现的次数
种类：大写字母，小写字母，数字，其他
思路:
1;既然用到键盘输入，肯定是Scanner
2:键盘输入的是字符串，那么： String str = sc.next();
3:定义四个变量，分别代表四种字符各自出现的次数
4:需要对字符串一个字，一个字检查，String -->char[] ,方法是toCharArray()
5:遍历charp[]字符，对当前字符的种类进行判断，并且用四个变量进行++操作
6：打印输出四个变量，分别代表四种字符出现的次数
*/
public class Demo07StringCount {
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        System.out.println("请输入一个字符串:");
        String input =sc.next();//获取键盘输入的字符串
        int countUpper = 0;//大写字母
        int countLower = 0;//小写字母
        int countNumber = 0;//数字
        int countOther = 0;//其他字符
        char[] charArray = input.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            char ch = charArray[i];//当前单个字符
            if('A'<=ch && ch <='Z'){
                countUpper++;
            }else if('a'<=ch&& ch <='z'){
                countLower++;
            }else if('0'<= ch && ch <='9'){
                countNumber++;
            }else{
                countOther++;
            }

        }
        System.out.println("大写字母有:"+ countUpper);
        System.out.println("小写字母有:"+ countLower);
        System.out.println("数字有:"+ countNumber);
        System.out.println("其他字符有:"+ countOther);
    }
}

6:static关键字

静态static关键字修饰成员
Student类

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

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        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 static String getRoom() {
        return room;
    }

    public static void setRoom(String room) {
        Student.room = room;
    }

}

Demo01StaticField类

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

static关键字
MyClass类

package com.itcat.day1;

public class MyClass {
    int num;//成员变量
    static int numStatic;//静态变量
    //成员方法
    public void method(){

        System.out.println("这是一个普通的成员方法。");
        System.out.println(num);
        System.out.println(numStatic);
    }
    //静态方法
    public static void methodStatic()
    {
        System.out.println("这是一个静态方法.");
        System.out.println(numStatic);
        //静态不能直接访问非静态【重点】
       // System.out.println(num);//错误写法

        //静态方法不能使用this关键字。
       // System.out.println(this);//错误写法
    }
}

Demo02StaticMethod类

package com.itcat.day1;

/*
一旦使用static修饰成员方法,那么这就成为了静态方法。静态方法不属于对象,而是属于类的。
如果没有static关键字，那么必须首先创建对象，然后通过对类名称来使用它
无论是成员变量，还是成员变量。如果使用了static,都推荐使用类名称进行使用。
静态变量；类名称.静态变量。
静态方法；类名称.静态方法();
注意事项：
1:静态只能直接访问静态，不能直接访问非静态
原因:因为在内存中【先】有静态内容，【后】有非静态内容。
2://静态方法不能用this
原因；this代表当前对象，通过谁调用的方法，谁就是当前对象。
*/
public class Demo02StaticMethod {
    public static void main(String[] args) {
        MyClass one = new MyClass();//首先创建对象
        //然后才能使用没有static关键字的内容
        one.method();
        //对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名来调用。
        one.methodStatic();//正确，不推荐
        MyClass.methodStatic();//正确，推荐

        myMethod();//对于本类中的静态方法，可以省略类名称。
        Demo02StaticMethod.myMethod();//完全等效
    }
    public static void myMethod(){
        System.out.println("自己的方法");
    }
}

static内存图

静态代码块：
Person类

package com.itcat.day1;

public class Person {
    static {
        System.out.println("静态代码块执行！");
    }
    public Person(){
        System.out.println("构造方法执行！");
    }
}

Demo4类

package com.itcat.day1;
/*
静态代码块的格式是：
public class 类名称{
static {
//静态代码块的内容
}
}
特点:当第一次用到本类时，静态代码块执行唯一的一次。
静态内容总是优先于非静态，所以静态代码块比构造方法先执行。

静态代码块的典型用途：
用来一次性对静态成员变量进行赋值。
*/
public class Demo4 {
    public static void main(String[] args) {
        Person one = new Person();
        Person two = new Person();
    }
}

7:Arrays类

package com.edu.cn;

import java.util.Arrays;

/*
java.util.Array是一个与数组相关的工具类，里面提供了大量的静态方法：用来实现数组常见的操作
public static String toString(数组);将参数数组变成字符串（按照默认格式:[元素1，元素2，元素3...])
public static void sort(数组）；按照默认升序对数组的元素进行排序

备注：
1：如果是数值，sort默认按照升序从小到大
2：如果是字符串，sort默认安装字母升序
3：如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持
*/
public class Demo1Arrays {
    public static void main(String[] args) {
        int [] intArray = {10, 20,30};
        //将int[]数组按照默认格式变成字符串
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr);

        int [] array1 = {2,1,3,10,6};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));

        String[] array2 = {"bbb","aaa","ccc"};
        System.out.println(Arrays.toString(array2));
    }
}

练习:

package com.edu.cn;
import java.util.Arrays;

/*题目
请使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印
*/
public class Demo02ArraysPractice {
    public static void main(String[] args) {
        String str = "asv76agfqwdfvasdf ";
        /*
        1:如何进行升序排列，sort
        2:必须是一个数组，才能用Arrays.sort方法
        3:String --->数组，用toCharArray();
        */
        char[] chars = str.toCharArray();
        Arrays.sort(chars);//对字符数组进行升序排列
        //需要倒序排列
        for (int i = chars.length - 1; i >= 0; i--) {
            System.out.print(chars[i]);
        }

    }
}

8:Math类

package com.edu.cn;=
import sun.nio.cs.ext.MacHebrew;
/*
java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作
public static double abs()//获取绝对值
public static double ceil(double num) //向上取整
public static double floor(double num);//向下取整
public static double round(double num);//四舍五入

Math.PI代表近似的圆周率常量（double)
*/
public class Demo03Math {
    public static void main(String[] args) {
        //获取绝对值
        System.out.println(Math.abs(3.14));//3.14
        System.out.println(Math.abs(0));  //0
        System.out.println(Math.abs(-2.5));//2.5
        System.out.println("=============================");
        //向上取整
        System.out.println(Math.ceil(3.9));//4.0
        System.out.println(Math.ceil(3.1));//4.0
        System.out.println(Math.ceil(3.0));//3.0
        System.out.println("============================");
        //向下取整
        System.out.println(Math.floor(30.1));//30.0
        System.out.println(Math.floor(30.9));//30.0
        System.out.println(Math.floor(31.0));//31.0
        System.out.println("============================");
        //四舍五入
        System.out.println(Math.round(20.4));//20
        System.out.println(Math.round(10.5));//11
    }
}