Java的第九篇文章——常用类上（StringBuilder、System、Math）-阿里云开发者社区

第九章常用类上

学习目标

StringBuilder类的方法
方法调用链
StringBuilder和String的互转
System类
Math类
数组相关操作

数组的翻转
数组的最值
数组的扩容
数组二分查找
冒泡排序
直接选择排序

字符串相关操作

字符串翻转
自定义trim
字符串出现的次数
字符出现的次数
哪个字符出现的最多

1.StringBuilder类的常用方法

（1）StringBuilder append(任意类型) 参数追加成字符串，无论参数写的是什么,变成字符串。相当于是字符串里面的 + 运算

public class StringBuilderTest {
    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder();
        builder.append("123");
        builder.append(32);
        builder.append(true);
        System.out.println(builder);
    }
}

方法调用链, 链式编程 :

链式编程：保证一个方法的返回值是一个对象，再使用这个对象调用的调用方法：对象.方法().方法().方法()......

public StringBuilder append(char[] str)，该方法有多种重载（由于参数不一样），其返回值是StringBuilder类，记住StringBuilder是可以改变自身的字符串的。而String类是返回一个新的地址。

public static void builderAppend2(){
    StringBuilder builder = new StringBuilder();
    //方法append() 返回值是StringBuilder
    //return this 返回值是this (谁调用,我是谁)
    builder.append("hehe").append(false).append(1.5).append(1); 
//执行的结果,是builder对象,继续使用builder对象调用方法
    System.out.println("builder = " + builder);
}

（2）StringBuilder insert(int 索引, 任意类型) 可以将任意类型的参数，插入到字符串缓冲区，指定索引。

public class StringBuilderTest {
    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder("1233451");
        builder.insert(1, "ad");
        System.out.println(builder);//结果是1ad233451
    }
}

（3）StringBuilder类的其他方法

nt length() 返回字符串缓冲区的长度
StringBuilder delete(int start,int end)删除缓冲区中的字符,包含开头索引,不包含结束索引
void setCharAt(int 索引,char ch)修改指定元素上的字符
StringBuilder reverse() 翻转字符串

1.1 StringBuilder对象和String对象的互转

（1）String对象转成StringBuilder对象 String --> StringBuilder

StringBuilder类的构造方法 StringBuilder(String str)
append方法 append(String str)

public class StringBuilderTest {
    public static void main(String[] args) {
        stringToStringBuilder();
    }
    public static void stringToStringBuilder(){
        //构造方法
        StringBuilder builder = new StringBuilder("abc");
        //对象的方法append
        builder.append("hello");
    }
}

注：static修饰的方法，也就是静态方法是可以在该类中直接调用的，不用new 对象，可以直接写出方法，在编译的过程中，JVM会根据就近原则，去找该方法。

（2）StringBuilder对象转成String对象 StringBuilder ->String

StringBuilder的方法toString()
String类的构造方法

/**
     *  StringBuilder -> String
     */
public static void stringBuilderToString(){
        StringBuilder builder = new StringBuilder();
        builder.append("我是字符串的缓冲区");
        //builder对象转成String对象,调用builder对象的方法 toString()
        String str = builder.toString();
        System.out.println(str);
        //String类的构造方法
        String s = new String(builder);
        System.out.println(s);
}

2.System类

System系统类 : 定义在java.lang包中

定义了大量常用的字段(成员变量)和方法，该类不能实例化对象，不能new，类中的成员全部是静态修饰,类名直接调用。

为什么该类不能new对象呢？

答：因为该类的构造器被私有化了！

2.1 System类的方法

（1）static long currentTimeMillis() 返回自1970年1月1日，午夜零时，到你程序运行的这个时刻，所经过的毫秒值，1000毫秒=1秒。

public static void currentTimeMillisTest(){
        long l = System.currentTimeMillis();
        System.out.println(l);
}

（2） static void arrayCopy( Object src,int srcPos,Object dest, int destPos,int length )复制数组的元素。

src : 要赋值的数据源,源数组
srcPos : 源数组的开始索引
dest : 要复制的目标数组
destPos : 目标数组的开始索引
length : 要复制的元素个数

public static void arrayCopyTest(){
        int[] ints = new int[]{1, 2, 3, 4, 5, 6};
        int[] ints1 = new int[5];
        System.arraycopy(ints,0,ints1,0,5);
        for (int i = 0; i < ints1.length; i++) {
            System.out.print(ints1[i]+",");
        }
}

（3）static Properties getProperties() 返回当前的操作系统属性

public static void getPropertiesTest(){
        /**
         *  static Properties getProperties() 返回当前的操作系统属性
         *  System.getProperty(String 键名)
         *  这是两个不一样的方法
         */
        Properties properties = System.getProperties();
        System.out.println(properties);
        String property = System.getProperty("os.name");
        System.out.println(property);
}

3.Math类

static double PI 圆周率
static double E 自然数的底数
static int abs(int a) 返回参数的绝对值
static double ceil(double d)返回大于或者等于参数的最小整数
static double floor(double d)返回小于或者等于参数的最大整数
static long round(double d)对参数四舍五入
static double pow(double a,double b ) a的b次幂
static double random() 返回随机数 0.0-1.0之间
static double sqrt(double d)参数的平方根

public static void main(String[] args) {
// System.out.println("Math.PI = " + Math.PI);
//  System.out.println("Math.E = " + Math.E);
//static int abs(int a) 返回参数的绝对值
    System.out.println(Math.abs(-6));
//static double ceil(double d)返回大于或者等于参数的最小整数
    System.out.println(Math.ceil(12.3)); //向上取整数
//static double floor(double d)返回小于或者等于参数的最大整数
    System.out.println("Math.floor(5.5) = " + Math.floor(5.5));//向下取整数
//static long round(double d)对参数四舍五入
    long round = Math.round(5.5); //取整数部分  参数+0.5
    System.out.println("round = " + round);
//static double pow(double a,double b ) a的b次幂
    System.out.println("Math.pow(2,3) = " + Math.pow(2, 3));
//static double sqrt(double d)参数的平方根
    System.out.println("Math.sqrt(4) = " + Math.sqrt(3));
// static double random() 返回随机数 0.0-1.0之间
    for(int x = 0 ; x < 10 ; x++){
        System.out.println(Math.random()); //伪随机数
    }
}

4.数组的相关操作

4.1 数组的翻转

所谓的数组的翻转例子 : 原始数组 {1,2,3,4} 翻转后是 {4,3,2,1}

数组的翻转不等于倒叙遍历

数组中元素位置的交换，数组的换位，借助一个变量

核心问题：数组中最远端的元素交换位置

/*
    * front和end标记不断向中间移动，两者对应下标的元素进行一个交换，
    * 当两个的值都一样或front的值大于end的值时，跳出循环
    * */
    public static void arrayReverse(int[] arr){
        int front = 0,end = arr.length - 1;
        //temp变量为中间变量
        int temp = 0;
        while (front < end){
            temp = arr[front];
            arr[front] = arr[end];
            arr[end] = temp;
            front++;
            end--;
        }
    }

4.2 数组的二分(折半)搜索法

数组的基本搜索法 : 判断一个元素是否存在于数组中

遍历数组,查找就可以
二分搜索法提高效率 : 前提是数组必须是有序的

/**
     *
     * @param arr 传进来的数组
     * @param key 想要查找的关键字
     * @return 返回查找到该元素的下标，没有则返回-1
     */
    public static int binarySearch(int[] arr,int key){
        int min = 0,max = arr.length - 1;
        int mid = ( min + max ) / 2;
        while(min <= max){
            if(key < arr[mid]) {
                max = mid - 1;
                mid = ( min + max ) / 2;
            } else if(key > arr[mid]){
                min = mid + 1;
                mid = ( min + max ) / 2;
            }else{
                return mid;
            }
        }
        return -1;
    }

4.3 数组的排序

在无序的数组中，对元素进行排序，默认都是升序

数组排序：元素在内存中的位置交换，效率最低。

选择排序，冒泡 (选择优化)，插入排序，折半排序，希尔排序，快速排序

4.3.1 冒泡排序（bubble）

核心思想：元素之间比较换位。冒泡排序的比较方式：相邻元素比较

public static void bubbleSort(int[] arr){
        int temp = 0;
        //flag为标记，标记冒泡没有发生交换，则数组已经有序，不用再进行过多趟的排序
        boolean flag = true;
        for (int i = 0; i < arr.length - 1; i++) {
            flag = true;
            for (int j = 0; j < arr.length - i - 1; j++) {
                if(arr[j]>arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = false;
                }
            }
            if (flag)
                break;
        }
}

4.3.2 选择排序

优化：不是每次比较完成都要换位，获取到最值，用这个最值在换位值，也就是每趟只是进行一次交换。

public static void selectSort(int[] arr){
        int temp = 0,k = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            k = i;
            for (int j = i + 1; j < arr.length; j++) {
                if(arr[j] < arr[k])
                    k = j;
            }
            temp = arr[k];
            arr[k] = arr[i];
            arr[i] = temp;
        }
    }

4.4 Arrarys工具类

java.util包中定义了类Arrays,数组操作的工具类.类不能创建对象,直接静态调用

Arrays类的静态方法

static void sort(数组) 对数组进行升序排列 (目前为止效率最快)
static int binarySearch(数组,查找的关键字) 对数组进行二分搜索法
static void fill(数组,填充的元素)
static String toString(数组) 返回数组字符串表现形式
static List asList(T...t) 元素转成List集合

public static void main(String[] args) {
        int[] arr = {1,5,9,10,15,22,27,30};
        //arrayToString(arr);
       // arraySort(arr);
       // System.out.println(Arrays.toString(arr));
        int index = arrayBinarySearch(arr,5);
        System.out.println(index);
        arrayFill();
    }
    /**
     * fill填充数组
     */
    public static void arrayFill(){
        int[] arr = {1,2,3,4,5};
        Arrays.fill(arr,6);
        System.out.println(Arrays.toString(arr));
    }
    /**
     * static int binarySearch(数组,查找的关键字) 对数组 进行二分搜索法
     * 返回元素在数组中出现的索引
     * 如果元素不存在,返回 (-插入点-1)
     * key : 放在数组中,保证有序的
     */
    public static int arrayBinarySearch(int[] arr,int key){
        int index = Arrays.binarySearch(arr, key);
        return index;
    }
    /**
     *  static void sort(数组) 对数组进行升序排列 (目前为止效率最快)
     */
    public static void arraySort(int[] arr){
        Arrays.sort(arr);
    }
    /**
     * static String toString(数组) 返回数组字符串表现形式
     * toString内部自动遍历数组
     */
    public static void arrayToString(int[] arr){
        String str =  Arrays.toString(arr);
        System.out.println(str);
    }

5.字符串相关操作

5.1 字符串翻转

数组可以转成字符串，字符串也能转成数组 (翻转数字)

/**
     * 翻转字符串的另一个实现
     */
    public static String  stringReverse2(String str){
        //str转成StringBuilder
        //StringBuilder builder = new StringBuilder(str);
       // builder.reverse();
        //字符串缓冲区转成字符串返回
        //return builder.toString();
       return   new StringBuilder(str).reverse().toString();
    }
    /**
     * 翻转字符串
     * 传递字符串,返回翻转后的字符串
     */
    public static String stringReverse(String str){
        //字符串转成数组
        char[] chars = str.toCharArray();
        //翻转数组
        for(int min = 0 ,max = chars.length - 1; min <= max ; max--,min++){
            char temp = chars[min];
            chars[min] = chars[max];
            chars[max] = temp;
        }
        //数组转成字符串
       return new String(chars);
    }

5.2 自定义trim()

功能：去掉字符串两边的空格

" abcd efg " ==>"abcd efg"

String中的基本方法涉及到匹配、分割、获取、替代都有正则表达式可以使用！！！

/**
     *  自定义的方法trim()
     *  "    abcde  fg  "
     *  "abcde  fg  "
     */
    public static String myTrim(String str){
        //去掉字符串开头的空格,方法替换
        str = str.replaceFirst(" +","");
        //判断字符串,是不是以空格结尾
        while (str.endsWith(" ")){ //"abcde  fg1"
            //截取字符串
            str = str.substring(0,str.length()-1);
        }
        return str;
    }

5.3 字符出现的次数

要求 : 指定字符串 "asdfg3435erAAEExc" ，统计处，小写字母，大写字母，数字，各自出现了多少次,不考虑其它字符。

实现思想 : 字符串换成数组,取出每个元素,分别统计 ASCII码熟悉

/**
     *  统计字符串中字符和数字出现的次数
     */
    public static void stringCount(String str){
        if (str == null)
            return;
        //定义三个计数器变量
        int upper = 0 , lower = 0 , number = 0;
        //字符串转成数组
        char[] chars = str.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            //取出每个元素
            char ch = chars[i];
            //判断ch字符的ASCII范围
            if ( ch >= 'A' && ch <= 'Z')
                //大写字母
                upper ++;
            else if ( ch >= 'a' && ch <= 'z')
                //小写字母
                lower ++;
            else if (ch >= '0' && ch <= '9'){
                //数字
                number ++;
            }
        }
        System.out.println("大写字母:"+upper);
        System.out.println("小写字母:"+lower);
        System.out.println("数字:"+number);
    }

Java的第九篇文章——常用类上（StringBuilder、System、Math）

第九章常用类上

1.StringBuilder类的常用方法

1.1 StringBuilder对象和String对象的互转

2.System类

2.1 System类的方法

3.Math类

4.数组的相关操作

4.1 数组的翻转

4.2 数组的二分(折半)搜索法

4.3 数组的排序

4.3.1 冒泡排序（bubble）

4.3.2 选择排序

4.4 Arrarys工具类

5.字符串相关操作

5.1 字符串翻转

5.2 自定义trim()

5.3 字符出现的次数

热门文章

最新文章

相关课程

相关电子书

相关实验场景

Java的第九篇文章——常用类上（StringBuilder、System、Math）

第九章 常用类上

1.StringBuilder类的常用方法

1.1 StringBuilder对象和String对象的互转

2.System类

2.1 System类的方法

3.Math类

4.数组的相关操作

4.1 数组的翻转

4.2 数组的二分(折半)搜索法

4.3 数组的排序

4.3.1 冒泡排序（bubble）

4.3.2 选择排序

4.4 Arrarys工具类

5.字符串相关操作

5.1 字符串翻转

5.2 自定义trim()

5.3 字符出现的次数

热门文章

最新文章

相关课程

相关电子书

相关实验场景

第九章常用类上