常用API第一部分

最新推荐文章于 2021-06-15 17:53:33 发布

weixin_懂否

最新推荐文章于 2021-06-15 17:53:33 发布

阅读量217

点赞数

分类专栏：笔记

本文链接：https://blog.csdn.net/weixin_48064839/article/details/106917979

版权

笔记专栏收录该内容

10 篇文章 0 订阅

订阅专栏

常用API第一部分

API使用步骤

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

API:应用程序编程接口。

1.Scanner类

功能：可以实现键盘输入数据，到程序当中。

引用类型的一般使用步骤

1.导包

import 包路径.类名称

如果使用的目录类，和当前处于同一路径，导包语句可以省略不写。

只用java.lang包下的内容不需要导包，其他都需要导包。

2.创建

类名称对象名 = new 类名称（）

3.使用

对象名.成员方法名();

代码实现：

package cn.itcast.day07.demo01;

import java.util.Scanner;//1.导包

/**
 * 1.键盘录入宇哥数字 int num = sc.nextInt();
 * 2.键盘录入一个字符串 String str = sc.next();
 */
public class Demo01Scanner {
    public static void main(String[] args) {
        //2.创建
        //System.in 代表键盘进行录入
        Scanner sc = new Scanner(System.in);
        //键盘录入宇哥数字
        int num = sc.nextInt();
        System.out.println("输入的数字是" + num);
        //键盘录入一个字符串
        String str = sc.next();
        System.out.println("输入的字符串是" + str);
         //其实不管怎样输入，都是字符串，然后再把字符串转化为不同的类型。
    }
}

练习1

package cn.itcast.day07.demo01;

import java.util.Scanner;

/**
 * 键盘录入两个数字求和
 * 思路：1.输入两个数字，所以用nextInt();
 */
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("两个数字的和为" + result);

    }
}

练习2：

package cn.itcast.day07.demo01;

import java.util.Scanner;

/**
 * 键盘输入三个数字，求出最大值
 * 思路：输入三尺数字 。调用三次nextInt();
 * 首先判断前两个数的最大值，然后再和第三个值做比较
 */
public class Demo03ScannerMax {
    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 temp = a > b ? a : b;
        int max = temp > c ? temp : c;
        System.out.println("输入数字的最大值为：" + max);
    }
}

2.匿名对象

定义：匿名对象就是只有右边的对象，没有左边的名字和赋值运算符。

代码实现：

package cn.itcast.day07.demo02;

public class Person {
    String name;
    public void showName(){
        System.out.println("我的名字是" + name);
    }
}


package cn.itcast.day07.demo02;

/**
 * 格式 new 类名称（）;
 * 注意事项：匿名对象只能让使用唯一的一次，下次使用不得不重新创建。
 * 如果确定一个对象只需要使用唯一的一次，那么可以使用匿名对象。
 */
public class Demo01Anonymous {
    public static void main(String[] args) {
        Person P = new Person();
        P.name = "赵又廷";
        P.showName();
        System.out.println("-------------------");
        new Person().name = "张三";
        new Person().showName();
    }
}

匿名对象作为方法的参数和返回值

代码实现：

package cn.itcast.day07.demo02;

import java.util.Scanner;

public class Demo02Anonymous {
    public static void main(String[] args) {
        //使用普通方式
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        System.out.println("输入的数字是" + num);
        //使用匿名对象方式
        int num1 = new Scanner(System.in).nextInt();
        System.out.println("输入的数字是" + num1);
        //使用一般写法传入参数
        Scanner sc1 = new Scanner(System.in);
        methodParam(sc1);
        //使用匿名对象传递参数
        methodParam(new Scanner(System.in));
      //使用匿名对象作为返回值
        Scanner scanner = methodReturn();
        int num4 = scanner.nextInt();
        System.out.println("输入的数字是" + num4);
    }
    public static void methodParam(Scanner sc){
        int num3 = sc.nextInt();
        System.out.println("输入的数字是" + num3);
    }
    public static Scanner methodReturn(){
//        Scanner scc = new Scanner(System.in);
//        return scc;
        return new Scanner(System.in);
    }
}

3.Random类

/**
 * Random 用来生成随机数字，使用起来分为三个步骤
 * 1.导包
 * import.java.util.Random;
 * 2.创建
 * Random r = new Random();
 * 3.使用
 * int num = r.nextInt();
 * 注意：获取一个int数字，若小括号留空，范围是int类型的所有范围，㕛正负两种。
 *       获取一个int随机数字，参数代表了范围，左闭右开区间。int num = r.nextInt(3);
 *       含义：【0，3） 也就是0-2
 */

代码示例：

package cn.itcast.day07.demo03;

import java.util.Random;

/**
 * Random 用来生成随机数字，使用起来分为三个步骤
 * 1.导包
 * import.java.util.Random;
 * 2.创建
 * Random r = new Random();
 * 3.使用
 * int num = r.nextInt();
 * 注意：获取一个int数字，若小括号留空，范围是int类型的所有范围，㕛正负两种。
 */
public class Demo01Random {
    public static void main(String[] args) {
        Random r = new Random();
        int num = r.nextInt();
        System.out.println("产生的随机数字为：" + num);
    }
}

Random生成指定范围的随机数

package cn.itcast.day07.demo03;

import java.util.Random;

public class Demo02Random {
    public static void main(String[] args) {
        Random r = new Random();
        for (int i = 0; i < 10; i++) {
            int num = r.nextInt(10);//生成0-9之间的随机数
            System.out.println(num);
        }
    }
}

练习1

package cn.itcast.day07.demo03;

import java.util.Random;

/**
 * 题目要求：
 * 根据imt 变量n的值，来获取穗局数字。范围[1.n]
 * 思路：
 * 1.定义一个随机便便，随意赋值。
 * 2.使用Random产生随机数
 * 3.若要实现替补要求，可以整体在产生随机数字后加1.
 * 3.打印输出
 */
public class Demo03Random {
    public static void main(String[] args) {
        int n = 5;
        Random r = new Random();
        for (int i = 0; i < 100; i++) {
            int num = r.nextInt(n) + 1;
            System.out.println(num);
        }

    }
}

练习2

猜数字小游戏：

package cn.itcast.day07.demo03;

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

/**
 * 练习：猜数字小游戏
 * 思路：
 * 1.首先应该产生一个随机数字，一旦产生就不在变化。使用Random的nextInt()方法
 * 2.需要键盘录入，所以使用Scanner
 * 3.对两个数字进行判断。
 *
 */
public class Demo04RandomGame {
    public static void main(String[] args) {
        Random r = new Random();
        int num = r.nextInt(100) + 1;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数字：");
        while (true){
            int guessNum = sc.nextInt();
            if (guessNum > num){
                System.out.println("太大了，请重新输入");
            }else if (guessNum < num){
                System.out.println("太小了，请重新输入");
            }else{
                System.out.println("恭喜你，猜对了！！！");
                break;
            }

        }
        System.out.println("游戏结束");
    }
}

使用fiot循环

package cn.itcast.day07.demo03;

import sun.plugin2.message.JavaScriptCallMessage;

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

public class Demo05RandomGame {
    public static void main(String[] args) {
        Random r = new Random();
        int num = r.nextInt(100) + 1;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数字：");
        for (int i = 5; i > 0; i--) {
            int guessNum = sc.nextInt();
            if (guessNum > num){
                System.out.println("太大了，请重新输入，你还有" +(i - 1)+ "次机会" );
            }else if (guessNum < num ){
                System.out.println("太小了，请重新输入，你还有" +(i - 1)+ "次机会" );
            }else {
                System.out.println("恭喜你，猜对了，游戏结束");
            }
        }
    }
}

4.ArrayList集合

对象数组

代码示例：

package cn.itcast.day07.demo04;

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;
    }
}




package cn.itcast.day07.demo04;

/**
 * 定义一个数组，用来存储三个Person对象
 */
public class Demo01Array {
    public static void main(String[] args) {
        //首先创建一个长度为3的数组，里面用来存放Person对象
        Person[] array = new Person[3];
        System.out.println(array);
        Person one = new Person("古力娜扎", 12);
        Person two = new Person("迪丽热巴", 22);
        Person three = new Person("张三", 33);
        //将one当中的地址值赋值给array的0号位置上。
        array[0] = one;
        array[1] = two;
        array[2] = three;

        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);

        System.out.println(array[1].getName() + array[1].getAge());
    }
}

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

ArrayList集合概述和基本使用

注意：

1.数组的长度不能发生改变，ArrayList集合的长度是可以发生改变的。

2.对于ArrayList集合来说，代表泛型，也就是装在集合红的元素的同一类型是什么，泛型只能是引用类型。

3.对于ArrayList集合来说，直接打印不是地址值，而是内容，如果内容为空，得到的是[].

代码实现：

package cn.itcast.day07.demo04;

import java.util.ArrayList;

public class Demo02ArrayList {
    public static void main(String[] args) {
        //创建一个集合，从jdk 1.7 开始，右侧尖括号中的内容可以省略不写。
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);//[]
        //给集合中添加内容需要用到add()方法。
        list.add("赵丽颖");
        list.add("迪丽热巴");
        list.add("古力娜扎");
        // list.add(10); 只允许添加String 类型，内容类型与泛型类型不一致。
        System.out.println(list);//[赵丽颖, 迪丽热巴, 古力娜扎]


    }
}

ArrayList集合的常用方法和遍历

public booleann add(E e) 向集合中添加元素，参数的类型和泛型一样。

注意：对于ArrayList集合来说，添加的动作一定成功，的返回值可以不写，但是对于其他集合来说，返回值不一定成功。

public E get(index) 从集合中获取元素，参数是索引编号，返回值是索引位置上的元素
public E remove 从集合中删除元素，参数是索引编号，返回值就是索引位置上移除的元素。
publi int size ()获取集合的尺寸长度，返回值就是集合元素的个数。

代码实现：

package cn.itcast.day07.demo04;

import java.util.ArrayList;

public class Demo03ArrayListMethod {
    public static void main(String[] args) {
        //穿件ArrayList集合
        ArrayList<String> list = new ArrayList<>();
        //向集合中添加元素，返回是否添加成功
        boolean bool = list.add("赵丽颖");
        list.add("迪丽热巴");
        list.add("古力娜扎");
        System.out.println("添加是否成功  " + bool);
        System.out.println(list);
        //从集合中获取元素
        String name = list.get(1);
        System.out.println("第一号元素是 " + name);
        //从集合中删除元素
        String remove = list.remove(2);
        System.out.println("被删除的人是  " + remove);
        //获取集合的长度
        int size = list.size();
        System.out.println("集合的长度为" + size);


    }
}

遍历集合

package cn.itcast.day07.demo04;

        import java.util.ArrayList;

public class Demo04ArrayListEach {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("迪丽热巴");
        list.add("古力娜扎");
        list.add("赵四");
        System.out.println(list);

        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

ArrayList集合存储基本类型

注意：如果想要在集合中存储基本类型，那么必须用基本类型的包装类。

基本数据类型	基本数据类型的包装类（引用类型）
byte	Byte
short	Short
int	Integer【注意】
long	Long
float	Float
double	Double
char	Character【注意】
boolean	Bolean

注意：从 jdk1.5+开始，支持自动装箱，自动拆箱。

自动装箱：基本类型 —》引用类型

自动拆箱：引用类型----》基本类型

代码实现：

package cn.itcast.day07.demo04;

import java.util.ArrayList;

public class Demo05ArrayListBasic {
    public static void main(String[] args) {
        ArrayList<String>list = new ArrayList<>();
        //使用基本数据类型的包装类
        ArrayList<Integer>list1 = new ArrayList<>();
        list1.add(10);
        list1.add(20);
        list1.add(30);
        System.out.println(list1);
        //从集合中获取数据
        Integer integer = list1.get(1);
        System.out.println(integer);
    }
}

练习

练习一

package cn.itcast.day07.demo05;

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

/**
 * 生成6个1-35之间的随机整数，添加到集合，并遍历集合
 */
public class Demo05ArrayListRandom {
    public static void main(String[] args) {
        //1.创建ArrayList集合
        ArrayList<Integer> list = new ArrayList<>();
        //1.创建Random对象
        Random r = new Random();
        for (int i = 0; i < 6; i++) {
            //3.生成6个1-35之间的随机数字
            int num = r.nextInt(33) + 1;
            //4.将生成的随机数字添加的集合中
            list.add(num);
        }
        //5.遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

    }

}

练习二

package cn.itcast.day07.demo05;

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

    public Student() {
    }

    public Student(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;
    }
}




package cn.itcast.day07.demo05;

import cn.itcast.day07.demo04.Person;

import java.util.ArrayList;

/**
 * 自定义四个学生对象，保存到集合，并遍历集合
 * 思路
 * 1.创建一个集合，保存四个学生对象
 * 2.创建四个学生对象，存入集合
 * 2.遍历集合
 */
public class Demo02ArrayListStudent {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        //创建四个Student对象
        Student stu = new Student("黄老邪", 80);
        Student stu1 = new Student("郭靖", 35);
        Student stu2 = new Student("欧阳锋", 88);
        Student stu3 = new Student("洪七公", 90);
        //将4个Student对象存入到集合中
        list.add(stu);
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            Student st = list.get(i);
            System.out.println("姓名  " + st.getName() + "   年龄    " + st.getAge());
        }
    }
}

练习三

ArrayList作为参数

package cn.itcast.day07.demo05;

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("王五");
        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++) {
            if (i == list.size() - 1) {
                System.out.print(list.get(i) + "}");
            } else {
                System.out.print(list.get(i) + "@");
            }
        }
    }
}

练习四

ArrayList作为返回值

代码实现：

package cn.itcast.day07.demo05;

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

/**
 * 题目：用一个大集合存入20个随机数字，筛选其中的偶数数字，存入小集合当中。
 * 要求：用自定义方法进行筛选
 * 分析：
 * 1.需要一个大集合，用来存随机数字
 * 2.随机数字就用Random
 * 3.用循环把随机数字存入大集合
 * 4.定义一个方法，进行筛选
 */
public class Demo04ArrayListReturn {
    public static void main(String[] args) {
        //1.需要一个大集合，用来存随机数字
        ArrayList<Integer> biglist = new ArrayList<>();
        // 2.随机数字就用Random
        Random r = new Random();
        //3.用循环把随机数字存入大集合
        for (int i = 0; i < 20; i++) {
            int num = r.nextInt(50) + 1;
            biglist.add(num);
        }
        //System.out.println(biglist.size());
        ArrayList<Integer> list = smallList(biglist);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("小集合中存的数字有" + list.size() + "个");
    }

    /**
     * 三要素：
     * 返回值类型：ArrayList
     * 方法名称 smallList
     * 参数列表 ArrList大集合
     */
    public static ArrayList<Integer> smallList(ArrayList<Integer> bigList) {
        //创建一个小集合，用来存储税基数字中的偶数
        ArrayList<Integer> smallList = new ArrayList<>();
        for (int i = 0; i < bigList.size(); i++) {
            Integer num = bigList.get(i);
            if (num % 2 == 0) {
                smallList.add(num);
            }

        }
        return smallList;
    }
}

5.String 类

字符串的概念与特点

特点：

1.字符串的内容永不可变【重点】

2.正是因为字符串的内容不可改变，所以字符串是可以共享使用的。

3.字符串效果上相当于char[]字符数组，但是底层原理是byte字节数组。

4.程序当中所有的双引号，都是字符串对象。就算没有new也是。

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

创建字符串的3+1种方式。

3种构造方法

1.public String();创建一个空白字符串，不含任何内容。

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

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

1种直接创建

1.String str = “helo”;

注意：对于字符串来说，直接写上双引号，就是字符串对象。

代码实现：

package cn.itcast.day08.demo01;

public class Demo01String {
    public static void main(String[] args) {
        //1.public String();创建一个空白字符串，不含任何内容。
        String str = new String();
        System.out.println("第一个字符串" + str);
        //2.public String(char[]array)根据字符数组的内容，来创建对应的字符串
        char[] charArray = {'A', 'B', 'C'};
        String str2 = new String(charArray);
        System.out.println("第二个字符串" + str2);
        //3..public String(byte[]array) 根据字节数组的内容，来创建对应的字符串。
        byte[] byteArray = {97, 98, 99};
        String str3 = new String(byteArray);
        System.out.println("第三个字符串是" + str3);
        //3.普通创建
        String str4 = "hello";
        System.out.println("第四个字符串是" + str4);
    }
}

字符串的常量池

代码实现：

package cn.itcast.day08.demo01;

/**
 * 字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中。new 的不在池当中。
 * 对于基本类型来说。 == 是对数值的比较。
 * 对于引用类型来说， == 是对【地址值】的比较。
 * 从jdk1.7开始，字符串常量池在堆当中。
 */
public class Demo02StringPool {
    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);//true
        System.out.println(str1 == str3);//false
        System.out.println(str2 == str3);//false
    }
}

执行原理：

字符串的比较相关方法

注意：

1.== 是对对象的地址值进行比较，如果需要对内容进行比较，可以使用连个方法

1.1 public boolean equals(Object obj){}参数可以是任何对象，只要参数是字符串，并且内容相同，就会返回true,不同则会返回false.

2.任何内容都能Object 进行接收。

3.equals 方法具有对称性，也就是a.quals(b) 和 b.quals(a)效果一样。

4。如果比较字符串一个常量一个变量推荐把常量字符串写在前面。推荐 “abc”.equals(str) 不推荐 str.equals(“abc”)

5。public boolean equalsIgnoreCase(String str){}忽略大小写比较内容（只有英文字母区分大小写）

代码实现：

package cn.itcast.day08.demo02;

public class Demo01SreingEquals {
    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(str2.equals("hello"));//true
        System.out.println("hello".equals(str1));//true
        String str4 = "abc";
        System.out.println("abc".equals(str4));//推荐
        System.out.println(str4.equals("abc"));//不推荐，如果str4为空，会出现空指针异常。
        System.out.println("--------------------------");
        String str5 = "abc";
        String str6 = "ABC";
        System.out.println(str5.equalsIgnoreCase(str6));
    }
}

字符串的获取相关方法

package cn.itcast.day08.demo02;

/**
 * String 当中与获取相关的常用方法有
 * public int length() 获取字符串的长度
 * public String concat(String str) 拼接字符串
 * public char charAt(int index)获取指定位置的单个字符
 * public int indexOf(String str) 查找参数字符串在本字符串中首次出现的索引位置。如果没有返回值-1值
 */
public class Demo02StringGet {
    public static void main(String[] args) {
        //获取字符串的长度
        int length = "sddgvdfbgfchbvcbfghbxgfhbgf".length();
        System.out.println("字符串的长度为" + length);
        System.out.println("================================");
        //拼接字符串
        String str1 = "hello";
        String str2 = "word";
        String str3 = str1.concat(str2);
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);//helloword 返回新的字符串
        System.out.println("===================================");
        //获取指定位置的单个字符
        String str4 = "substring";
        char charAt = str4.charAt(1);
        System.out.println(charAt);
        System.out.println("========================================");
        //查找参数字符串在本字符串中首次出现的索引位置。如果没有返回值-1值
        String str5 = "hellkite";
        int ll = str5.indexOf("ll");
        System.out.println(ll);
        int le = str5.indexOf("le");
        System.out.println(le);//没有，返回-1
    }
}

字符串的截取相关方法

代码实现：

package cn.itcast.day08.demo02;

/**
 * 字符串的截取方法
 * 1.public String subString(int length){};截取从参数位置，一直到字符串末尾，返回新的字符串
 * 2.public String subString(int begin,int end){};截取从开始位置到结束位置中间的字符转
 */
public class Demo03SubString {
    public static void main(String[] args) {
      String str1 = "helloword";
        String substring = str1.substring(1);
        System.out.println(str1);//字符串不变
        System.out.println(substring);//ellword 返回一个新的字符串
        System.out.println("===================================");
        String substring1 = str1.substring(2, 6);
        System.out.println(substring1);//llow
        System.out.println("=======================================");
        //下面这种情况，字符串的内容任然没有发生改变，两个字符串。"hello" "java"
        //本来保存的是 hello的地址值 0x666 后来改为了java的地址值0x999
        //所以是两个对象
        String str2 = "hello";
        System.out.println(str2);//hello
        str2 = "java";
        System.out.println(str2);//java
    }
}

字符串的转换相关方法

代码实现：

package cn.itcast.day08.demo02;

/**
 * 与字符串转换相关事务方法
 * public char[]toCharArray();将当前的字符串拆分成为字节数组作为返回值。
 * public byte[]getBytes();获取当前字符串底层的字节数组
 * public String replace(CharSequence oldString ,CharSequence,newString)
 * 将所有出现的老字符串替换成为新字符串，返回替换了之后的结果字符串。
 */
public class Demo04StringConvert {
    public static void main(String[] args) {
        //将当前的字符串拆分成为字节数组作为返回值。
        String str1 = "helloWord";
        char[] chars = str1.toCharArray();
        System.out.println(chars[0]);
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }
        System.out.println("====================================");
        //获取当前字符串底层的字节数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }
        System.out.println("====================================");
        //将所有出现的老字符串替换成为新字符串，返回替换了之后的结果字符串
        String str = "how do you do";
        String o = str.replace("o", "*");
        System.out.println(str);//how do you do
        System.out.println(o);//h*w d* y*u d*
        System.out.println("=======================================");
        String str2 = "你个垃圾";
        String s = str2.replace("垃圾", "**");
        System.out.println(str2);//你个垃圾
        System.out.println(s);//你个**
    }
}

字符串的分割方法

代码实现：

 package cn.itcast.day08.demo02;

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

练习

练习一

package cn.itcast.day08.demo02;

/**
 * 题目：定义一个方法，把数组[1,2,3]按指定格式拼接成一个字符串，格式[word1#word2#word3]
 * 思路：
 * 1.首先定义一个数组int[]array = {1,2,3};
 * 2.定义一个方法，把数组转换为字符串。
 * 三要素：
 * 返回值类型 String
 * 方法名称 arrayToString
 * 参数 int[]array
 * 用到：for循环 ，字符串拼接，判断是否是最后一个
 */
public class Demo06StringPractice {
    public static void main(String[] args) {
        //首先定义一个数组
        int[] array = {1, 2, 3};
        String arrayToString = arrayToString(array);
        System.out.println(arrayToString);
    }

    //定义一个方法
    public static String arrayToString(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;
    }
}

练习二

package cn.itcast.day08.demo02;

import java.util.Scanner;

/**
 * 题目：键盘录入一个字符串，统计各种字符出现的次数。
 * 种类：大写字母，小写字母，数字，其他
 * 思路
 * 1.既然是键盘录入，要用到Scanner
 * 2.定义四个变量，分别用来统计四种字符出现的次数。
 * 3.需要对字符串进行逐一检查，需要用到toCharArray（）方法。
 * 4.对字符数组进行遍历，并对四种类型进行判断，做++操作。
 * 5.打印输出四个变量，分别代表四种字符出现的次数。
 */
public class Demo7StringCount {
    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[] chars = input.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char ch = chars[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关键字概述

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

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

代码实现：

package cn.itcast.day08.demo03;

public class Student {
    private int id;//学号
    private String name;//姓名
    private int age;//年龄
    static String room;//所在教室
    private static int idCounter;//学号计数器 ，每当new一个新的对象，计数器加1.
    public Student(){
       ++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;
    }
}




package cn.itcast.day08.demo03;

public class Demo03StaticField {
    public static void main(String[] args) {
        Student one = new Student("张三 ", 23);
        one.room = "101教室";
        System.out.println("姓名 " + one.getName() + "年龄  " + one.getAge() + " 学号 " + one.getId() + " 所在班级 "
                + one.room);
        Student two = new Student("李四 ", 24);
        System.out.println("姓名 " + two.getName() + "年龄  " + two.getAge() + " 学号 " + two.getId() + " 所在班级 "
                + two.room);
    }
}

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

一旦方法中含有static关键字修饰成员发方法，这就属于静态方法，静态变量不属于对象，而是属于类。
 1.如果没有static关键字，那么首先得创建对象，然后通过对象名调用。
 2.入股有static 关键字，那么不需要创建对象，可以直接通过类名称.方法名进行调用。
 3.无论是成员变量还是成员方法，都可以通过类名称进行调用。
 格式：
  静态变量 类名称.成员变量名
  静态方法 类名称.成员方法名
注意事项：
  1.静态不能直接访问非静态。
  原因：因为在内存当中是先有的静态内容，后有的非静态内容。
  后人可以知道先人，但是先人不会知道后人。
  2，静态方法中不能用this.
  原因：this代表当前对象，谁调用了该对象，谁就是this

package cn.itcast.day08.demo03;

public class MyClass {
    int num; //成员变量
    static int staticNum;//静态变量
    //成员方法
    public void method() {
        System.out.println("这是一个成员方法。");
        System.out.println(num); //非静态可以访问非静态
        System.out.println(staticNum);//非静态也可以访问静态。
    }
    //静态方法
    public static void staticMethod() {
        System.out.println("这是一个静态方法。");
        System.out.println(staticNum); //静态可以访问静态
        //System.out.println(num ); 错误写法 静态不可以访问非静态
        //静态方法中不能使用this关键字
        //System.out.println(this);错误写法
    }
}



package cn.itcast.day08.demo03;

/*
一旦方法中含有static关键字修饰成员发方法，这就属于静态方法，静态变量不属于对象，而是属于类。
 1.如果没有static关键字，那么首先得创建对象，然后通过对象名调用。
 2.入股有static 关键字，那么不需要创建对象，可以直接通过类名称.方法名进行调用。
 3.无论是成员变量还是成员方法，都可以通过类名称进行调用。
 格式：
  静态变量 类名称.成员变量名
  静态方法 类名称.成员方法名
注意事项：
  1.静态不能直接访问非静态。
  原因：因为在内存当中是先有的静态内容，后有的非静态内容。
  后人可以知道先人，但是先人不会知道后人。
  2，静态方法中不能用this.
  原因：this代表当前对象，谁调用了该对象，谁就是this
* */
public class Demo02StaticMethod {
    public static void main(String[] args) {
        MyClass obj = new MyClass();//首先创建对象
        obj.method();//通过对象名。方法名进行调用。
        MyClass.staticMethod();//对于静态方法，可以直接用类名.方法名进行调用

        method();//如果在本类中调用本类的静态方法，类名称可以省略。
        Demo02StaticMethod.method();//与上述方法等效
    }

    public static void method() {
        System.out.println("本类中的静态方法");
    }
}

静态static的内存图

静态代码块

package cn.itcast.day08.demo03;

public class Person {
    static {
        System.out.println("静态代码块执行了");
    }

    public Person() {
        System.out.println("构造方法执行了");
    }
}


package cn.itcast.day08.demo03;

/**
 * 静态代码块格式
 * public class 类名称{
 * static{
 * 静态代码块
 * }
 * }
 * 特点：当第一次用到本类时，静态代码块执行唯一的一次。
 * 静态优先于非静态，所以静态代码块优先执行于构造方法。
 * 典型用途：用来一次性的对成员变量进行赋值。
 */
public class Demo01Static {
    public static void main(String[] args) {
        Person one = new Person();
        System.out.println("========================");
        Person twp = new Person();

    }
}

7.Arrays工具类

代码实现

package cn.itcast.day08.demo04;

import java.util.Arrays;

/**
 * java.util.Arrays 是一个与数组相关的工具类，里面有大量的静态方法，用来实现数组常见的操作。
 * public static String toString(数组) 将参数数组变成字符串，按照默认格式[元素1，元素2，元素3]
 * public static void sort(数组)按照默认升序对数组元素进行排序
 * 备注
 * 1.如果是数值，sort默认升序排列。
 * 2.如果是字符串，sort默认按字母升序
 * 3.如果是自定义类型，那么这个类需要有Comparable或者Comparator接口的支持（今后学习）
 */
public class Demo01Arrays {
    public static void main(String[] args) {
     int[]array1 = {11,23,23,45,3};
     //将int数组按照默认格式变成字符串
        String toString = Arrays.toString(array1);
        System.out.println(toString);
        //对array1进行排序
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));
        //对字符串进行排序
        String[]array2 = {"aaa","ccc","bbb"};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));// aaa,bbb,ccc
    }
}

练习：

package cn.itcast.day08.demo04;

import java.util.Arrays;

/**
 * 题目：随机定义一个字符串，按照升序排列，并倒序打印
 */
public class Demo02ArraysPractice {
    public static void main(String[] args) {
        //1.定义一个字符串
        String str = "asdasdvdfgrtgxchbjdwjyerdwiasldcnbvjxcbbjc736r37";
        //2.将字符串转变为字符数组
        char[] chars = str.toCharArray();
        //3.把字符数组按照升序排列
        Arrays.sort(chars);
        //4，倒序打印
        for (int i = chars.length - 1; i >= 0; i--) {
            System.out.println(chars[i]);
        }
    }
}

8.Math类

常用方法

package cn.itcast.day08.demo04;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

/**
 * java.util.Math是一个与数学相关的工具类，里面有大量的静态方法，用来实现常见的数学运算操作。
 * public static double abs(double num); 获取绝对值
 * public static double ceil(double num); 向上取整
 * public static double floor(double num) 向下取整
 * public static long round(double num) 四舍五入
 * Math.PT代表近视圆周率
 */
public class Demo03Math {
    public static void main(String[] args) {
     //获取绝对值
        System.out.println(Math.abs(11));//11
        System.out.println(Math.abs(-12));//12
        System.out.println(Math.abs(11.99));//11.99
        System.out.println("==============================");
    //向上取整
        System.out.println(Math.ceil(11.9));//12
        System.out.println(Math.ceil(10.1));//11
        System.out.println(Math.ceil(10));//10
        System.out.println("=========================");
    //向下取整
        System.out.println(Math.floor(11.1));//11
        System.out.println(Math.floor(11.9));//11
        System.out.println(Math.floor(11.0));//11
        System.out.println("======================");
    //四舍五入
        System.out.println(Math.round(11.4));//11
        System.out.println(Math.round(11.5));//12
        System.out.println("========================");
    //圆周率
        System.out.println(Math.PI);
    }
}

练习

package cn.itcast.day08.demo04;

/**
 * 题目：计算在-10.8 到5.9 之间绝对值大于6或者小于2的整数有多少个。
 */
public class Demo04MathPratice {
    public static void main(String[] args) {
        int count = 0;
        double min = -10.8;
        double max = 5.9;
        for (int i = (int) min; i < max; i++) {
            int abs = Math.abs(i);
            if (abs > 6 || abs < 2.1) {
                System.out.println(i);
                count++;
            }
        }
        System.out.println("总共有" + count);
    }
}