JAVA-5-String类和StringBuffer类、二维数组、形参、冒泡排序及选择排序、Arrays数组工具类

一：练习String和StringBuffer两个类
（1）需求：有abasdcalsjdfasf34asfjsfasf一段字符串，找出其中重复最多的字符，和重复最少的字符和重复的次数！
　　在这里有两种方法，第一种方法是循规蹈矩，步步为营。第二种方法则巧用数组索引为整数且字符也可以作为整数的特性，代码相对简洁。
方法一，如下：

package com.edu_02;

public class Work1 {
    public static void main(String[] args) {
        /**
         * 1.筛选出字符串中出现过的字符
         * 2.统计出现过的字符的次数
         * 3.拿出里面出现次数最多和最少的次数以及对应的字符
         */
        //1.筛选出字符串中出现过的字符
        String s = "abasdcalsjdfasf34asfjsfasf";
        char[] chs = s.toCharArray();

        StringBuffer sb = new StringBuffer();
        //遍历这个字符数组
        for (int i = 0; i < chs.length; i++) {
            //System.out.println(chs[i]);
            //sb.append(chs[i]);
            //将sb转换成String，sb.toString
            //需要调用String中的contains(String str),这个方法
            //需要将遍历出来的字符转换成字符串，valueOf(),直接加上一个空串
            if (!sb.toString().contains(String.valueOf(chs[i]))) {
                sb.append(chs[i]);
            }
        }

        //System.out.println(sb);
        //2.统计出现过的字符的次数
        String str = sb.toString();
        int[] arr = new int[str.length()];
        for (int i = 0; i <str.length() ; i++) {
            int count  = 0;
            for (int j = 0; j < chs.length; j++) {
                if (str.charAt(i)==chs[j]) {
                    count ++;
                }
            }
            //System.out.println(count);
            arr[i] = count;
        }


        //求出数组arr中的最大值和最小值
        int max = arr[0];
        int min = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max<arr[i]) {
                max = arr[i];
            }

            if (min>arr[i]) {
                min = arr[i];
            }
        }

        //System.out.println(max);
        //System.out.println(min);
        for (int i = 0; i < arr.length; i++) {
            if (max==arr[i]) {
                System.out.println(str.charAt(i)+"  "+max);
            }

            if (min==arr[i]) {
                System.out.println(str.charAt(i)+"  "+min);
            }
        }
    }
}

方法二：
①找出出现次数最多的字符对应的ASCII码值，及最多次数

package homework;
public class GetMax {
    public void max(String s){
        int max=0;//用以记录最大出现次数
        int[] count=new int[127];//数组count元素默认全为0
        //数组索引和字符的ASCII码一一对应，这里数组count为临时计数用的数组 
        //数组count的长度只要大于等于“z”的ASCII码就行了
        for (int i = 0; i < s.length(); i++) {//循环字符以做统计
            char a=s.charAt(i); //取出字符串中的单个字母
            count[a]++;//找到取出的字符对应的数组count的索引，并将对应元素加1
            if (count[a]>max) {
                max=count[a];//检测记录次数最大值
            }
        }

        System.out.println(max);

        //根据max，依次和count中存储的次数数据比较
        //取出元素值与max相等的数据对应的索引值
        //索引值即为出现次数最多的字符对应的ASCII码值
        for (int j = 0; j < count.length; j++) {
            if (count[j]==max) {
                System.out.println(j);
            }
        }
    }
}

②找出出现次数最少的字符对应的ASCII码值，及最少次数

package homework;
public class GetMin {
    public void min(String s){
        int min=1;
        int[] count=new int[127];
        for (int i = 0; i < s.length(); i++) {
            char a=s.charAt(i);
            count[a]++;
            if (count[a]<=min) {
                min=count[a];

            }
        }

        System.out.println(min);    

        for (int j = 0; j < count.length; j++) {
            if (count[j]==min) {
                System.out.println(j);
            }
        }
    }
}

③进行测试：

package homework;
public class Homework02 {
    public static void main(String[] args) {
        String s="abasdcalsjdfasf34asfjsfasf";
        GetMax a = new GetMax();
        a.max(s);
        System.out.println("--------------");
        GetMin b = new GetMin();
        b.min(s);
    }
}

（2）需求：统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)

package com.edu_02;
public class Work4 {
    public static void main(String[] args) {
        //统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符) 
        String s = "sdfsdfSFXZCAED3454e56";
        //将字符创转换成字符数组
        char[] chs = s.toCharArray();
        //定义三个统计变量
        int numberCount = 0;
        int smallCount = 0;
        int bigCount = 0;

        //for循环遍历并且判断统计出现的次数
        for (int i = 0; i < chs.length; i++) {
            if (chs[i]>='0'&&chs[i]<='9') {
                numberCount++;
            }

            if (chs[i]>='a'&&chs[i]<='z') {
                smallCount++;
            }

            if (chs[i]>='A'&&chs[i]<='Z') {
                bigCount++;
            }
        }
        System.out.println(numberCount);
        System.out.println(smallCount);
        System.out.println(bigCount);
    }
}

（3）需求：把数组中的数据按照指定格式拼接成一个字符串(拼接成如下格式：[1,2,3,4,5])

package com.edu_02;

public class Work3 {
    public static void main(String[] args) {
        //把数组中的数据按照指定格式拼接成一个字符串(拼接成如下格式：[1,2,3,4,5]) 
        int[] arr = {2,3,56,0,7,8};
        printArr(arr);
    }

    private static void printArr(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i==arr.length-1) {
                System.out.print(arr[i]+"]");
            }else{
                System.out.print(arr[i]+",");
            }
        }
    }
}

（4）需求：写一个方法判断一个字符串是否是对称的

package com.edu_02;
public class Work2 {
    public static void main(String[] args) {
        //写一个方法判断一个字符串是否是对称的
        String s = "abc";
        //System.out.println(isDuiCheng(s));
        isDuiCheng2(s);
    }
//方法一：
    private static boolean isDuiCheng2(String s) {
//      StringBuffer sb = new StringBuffer(s);
//      sb.reverse();
//      return s.equals(sb.toString());
        return new StringBuffer(s).reverse().toString().equals(s);
    }
//方法二：
    private static boolean isDuiCheng(String s) {
        boolean flag = true;
        char[] chs = s.toCharArray();
        int maxIndex = chs.length - 1;
        for (int i = 0; i < chs.length; i++) {
            if (chs[i]!=chs[maxIndex]) {
                flag = false;
                break;
            }
            maxIndex--;
        }
        return flag;
    }
}

二：讲解二维数组
2.1二维数组：其实二维数组其实就是一个元素为一维数组的数组。
　　动态初始化方式一（指定有多少个长度相同的一维数组）：
　　　　数据类型[][] 变量名 = new 数据类型[m][n];
　　　　　　m表示这个二维数组有多少个一维数组
　　　　　　n表示每一个一维数组的元素个数

package com.edu_01;
public class ArrayArrayDemo {
    public static void main(String[] args) {
//      需求：请定义一个二维数组,二维数组有三个一维数组,每个一维数组有两个元素。
        int[][] arr = new int[3][2];
//      1.打印二维数组名称
        System.out.println(arr);//[[I@33abb81e

//      2.打印每一个一维数组
        System.out.println(arr[0]);//[I@4ec4d412
        System.out.println(arr[1]);//[I@5c3f1224
        System.out.println(arr[2]);//[I@30c028cc

//      3.不给元素赋值打印元素
        //二维数组中的第一个一位数组的0号元素
        System.out.println(arr[0][0]);//0
        System.out.println(arr[1][1]);//0

//      4.赋值后打印元素
        arr[1][0] = 10;
        arr[2][0] = 20;
        System.out.println(arr[1][0]);
        System.out.println(arr[2][0]);
    }
}

2.2动态初始化方式二（指定二维数组中有多少个一维数组，每一个一维数组的长度不固定）：
　　数据类型[][] 变量名 = new 数据类型[ｍ][ｎ];
　　　　注意：m这个数据必须给出，后面的数据可以不给

package com.edu_01;
public class ArrayArrayDemo2 {
    public static void main(String[] args) {
        //需求：定义一个有3个一维数组的二维数组,每一个一维数组的长度不固定
        int[][] arr = new int[3][];

        //3.打印二维数组中每一个一维数组的名称
        System.out.println(arr[0]);//null
        System.out.println(arr[1]);//null
        System.out.println(arr[2]);//null

        //1.给这个二维数组的每一个一维数组的元素赋值
        //arr[0] = {1,2,3};//在这里无法使用一维数组的静态初始化给二维数组中的每一个元素赋值
        //第一个一维数组有两个元素
        arr[0] = new int[2];
        arr[0][0] = 10;
        arr[0][1] = 20;

        //第二个一维数组，长度为3
        arr[1] = new int[3];
        arr[1][0] = 2;
        arr[1][1] = 3;
        arr[1][2] = 4;

        //第三个一维数组，长度为2
        arr[2] = new int[2];
        arr[2][0] = 4;
        arr[2][1] = 5;

        //2.打印二维数组的名称
        System.out.println(arr);//[[I@7f39ebdb

        //3.打印二维数组中每一个一维数组的名称
        System.out.println(arr[0]);//[I@4ec4d412
        System.out.println(arr[1]);//[I@5c3f1224
        System.out.println(arr[2]);//[I@30c028cc

        //4.打印二维数组中的每一个一位数组中的元素（手动打印几个即可）
        System.out.println(arr[0][0]);
        System.out.println(arr[2][0]);  
    }
}

2.3 二维数组的静态初始化：
　　静态初始化：
　　　　数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
　　简化格式：
　　　　数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

package com.edu_01;
public class ArrayArrayDemo3 {
    public static void main(String[] args) {
        //需求：定义一个里面有3个长度一样的一维数组的二维数组（使用静态初始化）
        int[][] arr = new int[][]{{1,2},{3,4},{5,6}};//new int[3][2];

        //需求：定义一个里面有3个长度不一样的一维数组的二维数组（使用静态初始化）
        int[][] arr2 = {{1,2},{3,4,5},{6,7,8,9}};//new int[3][];
    }
}

2.4 二维数组的遍历：需求：定义一个里面有3个长度不一样的一维数组的二维数组，并遍历

package com.edu_01;
public class ArrayArrayDemo4 {
    public static void main(String[] args) {
        //定义一个三个长度不意义样的一位数组的二维数组，并遍历
        int[][] arr = {{1,2},{3,4,5},{6,7,8,9,0}};

        //利用for循环遍历二维数组
        for (int i = 0; i < arr.length; i++) {
            //拿到每一个一维数组之后，遍历一位数组中的每一个元素
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }
    }
}

2.5 二维数组的求和：
公司年销售额求和，某公司按照季度和月份统计的数据如下：单位(万元)
　　第一季度：22,66,44　　第二季度：77,33,88
　　第三季度：25,45,65　　第四季度：11,66,99

package com.edu_01;
public class ArrayArrayDemo5 {
    public static void main(String[] args) {
        //创建对应的二维数组
        int[][] arr = {{22,66,44},{77,33,88},{25,45,65},{11,66,99}};

        //遍历二维数组并将每一个元素的值加起来
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            //拿到每一个一维数组之后，遍历每一个一维数组，加起来
            for (int j = 0; j < arr[i].length; j++) {
                sum+=arr[i][j];
            }
        }
        System.out.println(sum);
    }
}

三：形式参数问题

package com.edu_02;
public class ArgsDemo {
    public static void main(String[] args){
        int a = 10;
        int b = 20;
        System.out.println("a:"+a+",b:"+b); //10,20
        change(a,b);
        System.out.println("a:"+a+",b:"+b); //a:10,b:20

        int[] arr = {1,2,3,4,5};
        change(arr);
        System.out.println(arr[1]); //4
    }

    public static void change(int a,int b) { 
        System.out.println("a:"+a+",b:"+b); //10,20
        a = b; 
        b = a + b; 
        System.out.println("a:"+a+",b:"+b);//20,40
    }

    public static void change(int[] arr) { 
        for(int x=0; x<arr.length; x++) {
            //如果数组的元素值是偶数，就变为以前的2倍。
            if(arr[x]%2==0) {
                arr[x]*=2; 
            }
        }
    }
}

结论：
　　如果形式参数是基本类型：形式参数的改变，不影响实际参数。
　　如果形式参数是引用类型：形式参数的该变，直接影响实际参数。
　　
四 .数组的高级操作（冒泡排序，选择排序，数组工具类，练习）
（1）：冒泡排序
ａ：冒泡排序基本概念是：
　　　　相邻的两个元素进行比较，小的放前面，大的放后面
ｂ ：分析比较过程
　　　　第一次比较：比较了4次，最大的值放到了最后
　　　　第二次比较：比较了3次，次大的值放到了倒数第二
　　　　。。。依次类推

package com.edu_03;
public class ArraySortDemo {
    public static void main(String[] args) {
        //使用冒泡排序给数组int[] arr = { 24, 69, 80, 57, 13 };进行排序
        //创建一个数组
        int[] arr = { 24, 69, 80, 57, 13 };

        for (int j = 0; j < arr.length-1; j++) {//外层循环控制比较的次数
            for (int i = 0; i < arr.length - 1 - j ; i++) {
                //-1是为了防止数组越界，-j是为了提高比较的效率
                if (arr[i]>arr[i+1]) {
                    //找一个中间变量
                    int temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }   
        }
        printArr(arr);
    }

    //写一个方法打印数组
    public static void printArr(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"  ");
        }
        System.out.println();
    }
}

（2）：选择排序：
a：选择排序概念：
　　　　从0索引开始，依次和后面的每一个元素进行比较
　　　　第一次比较完毕，最小值出现在了最小索引处
　　　　第二次比较完毕，次小值出现在了次小索引处
　　　　　…
　　　　完毕后，就排序了。

package com.edu_03;
public class ArraySortDemo2 {
    public static void main(String[] args) {
        //使用选择排序对数组进行排序：int[] arr = { 24, 69, 80, 57, 13 };
        int[] arr = { 24, 69, 80, 57, 13 };

        for (int j = 0; j < arr.length-1; j++) {
            for (int i = j+1; i < arr.length; i++) {
                if (arr[j]>arr[i]) {
                    int temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
        }
        printArr(arr);
    }

    //写一个方法打印数组
        public static void printArr(int[] arr){
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i]+"  ");
            }
            System.out.println();
        }
}

（3）Arrays数组工具类
a： 针对数组进行操作的工具类。提供了排序，转换等功能。
b： 成员方法：
　　　　public static String toString(int[] a):把数组转成字符串
　　　　public static void sort(int[] a):对数组进行排序（有重载）

（4）练习（运用冒泡排序、选择排序和数组工具类三种方式实现）
　　　　把字符串中的字符进行排序。
　　　　举例：”dacgebf”
　　　　结果：”abcdefg”

package array;
//冒泡排序
public class Paixu {
    public static void main(String[] args) {
        String s="dacgebf";
        char[] chs =s.toCharArray();
        for (int i = 0; i < chs.length-1; i++) {
            for (int j = 0; j < chs.length-1-i; j++) {
                if (chs[j]>chs[j+1]) {
                    char temp=chs[j];
                    chs[j]=chs[j+1];
                    chs[j+1]=temp;
                }
            }
        }
        for (int i = 0; i < chs.length; i++) {
            System.out.print(chs[i]+"  ");
        }   
    }
}

package array;
//选择排序
public class Xuanze {
    public static void main(String[] args) {
        String s="dacgebf";
        char[] chs =s.toCharArray();
        for (int i = 0; i < chs.length-1; i++) {
            for (int j = i+1; j < chs.length; j++) {
                if (chs[j]<chs[i]) {
                    char temp=chs[j];
                    chs[j]=chs[i];
                    chs[i]=temp;
                }
            }
        }
        for (int i = 0; i < chs.length; i++) {
            System.out.print(chs[i]+"  ");
        }   
    }
}

package array;
//数组工具类
import java.util.Arrays;
public class PaixuDemo {
    public static void main(String[] args) {
        String s="dacgebf";
        char[] chs = s.toCharArray();
        Arrays.sort(chs);
        System.out.println(Arrays.toString(chs));
    }
}

（5）需求：从键盘输入10个数字,用冒泡排序进行从小到大的排序

package homework;
import java.util.Arrays;
import java.util.Scanner;//导包
public class Demo02 {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);//创建键盘录入对象
        int[] arr=new int[10];//定义一个数组用以接收数据
        System.out.println("请输入10个数");
        for (int i = 0; i < 10; i++) {
            int a=sc.nextInt();//获取键盘录入数据   
            arr[i]=a;
        }
        //冒泡排序
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j]>arr[j+1]) {
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        //利用数组工具类实现打印输出
        System.out.println(Arrays.toString(arr));
    }
}