笔记（4月8日）

一：
讲解String和StringBuffer两个类


二：
2.1
二维数组：其实二维数组其实就是一个元素为一维数组的数组。

动态初始化方式一（指定有多少个长度相同的一维数组）：

数据类型[][] 变量名 = new 数据类型[m][n];

m表示这个二维数组有多少个一维数组
n表示每一个一维数组的元素个数

需求：请定义一个二维数组,二维数组有三个一维数组,每个一维数组有两个元素。

int [] [] a = new int [3][2]；

1.打印二维数组名称 （0x001）
2.打印每一个一维数组（0x0001）
3.不给元素赋值打印元素（0）
4.赋值后打印元素

画出内存图解

2.2
动态初始化方式二（指定二维数组中有多少个一维数组，每一个一维数组的长度不固定）：
数据类型[][] 变量名 = new 数据类型[m][];


注意：
m这个数据必须给出，后面的数据可以不给

需求：定义一个有3个一维数组的二维数组
1.给这个二维数组的每一个一维数组的元素赋值
仅可用此种方式：
arr[0] = new int[2];
arr[0][0] = 1;
arr[0][1] = 2;

不能用此种方式：
/*
arr[0] = {1,2};
arr[1] = {5,6,7};
arr[2] = {4};
*/

2.打印二维数组的名称（0x001）
3.打印二维数组中每一个一维数组的名称（null）
4.打印二维数组中的每一个一位数组中的元素（手动打印几个即可）

画出内存图解

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


简化格式：
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

需求：定义一个里面有3个长度一样的一维数组的二维数组（使用静态初始化）
需求：定义一个里面有3个长度不一样的一维数组的二维数组（使用静态初始化）

2.4 二维数组的遍历：

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

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


}

三：形式参数问题
看程序写结果（画内存图进行分析）
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); //10,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.1 冒泡排序基本概念是：
相邻的两个元素进行比较，小的放前面，大的放后面
1.2画图讲解冒泡排序，int[] arr = { 24, 69, 80, 57, 13 };


1.4 文字分析比较过程
第一次比较：比较了4次，最大的值放到了最后
第二次比较：比较了3次，次大的值放到了倒数第二
。。。依次类推




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

2.2 画图讲解选择排序规则

2.3 运用选择排序int[] arr = { 24, 69, 80, 57, 13 };进行排序

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


}

三：Arrays数组工具类
3.1 针对数组进行操作的工具类。提供了排序，转换等功能。


3.2 
* 成员方法：
* public static String toString(int[] a):把数组转成字符串
* public static void sort(int[] a):对数组进行排序（有重载）


四：练习（运用冒泡排序和数组工具类两种方式实现）
* 把字符串中的字符进行排序。
* 举例：”dacgebf”

* 结果：”abcdefg”

package com.edu_05;


import java.util.Arrays;


public class StringSortDemo {
public static void main(String[] args) {
//使用冒泡排序
String s = "dacgebf";
//转换成字符数组
char[] chs = s.toCharArray();
/*//使用冒泡排序对字符根据ascii码表进行排序
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;
}
}
}*/

//使用Arrays里面的sort()方法给字符数组进行排序
Arrays.sort(chs);
//打印数组
System.out.println(Arrays.toString(chs));

}


}

五：作业

1.键盘录入一个字符串，判断是否是对称的，并且给出提示（2种方式实现）

package com.edu_408;


import java.util.Scanner;


//键盘录入一个字符串，判断是否是对称的，并且给出提示（2种方式实现）
public class Work4 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("输入字符串");
String s = sc.next();
//方法一：
// StringBuffer sb = new StringBuffer(s);
// StringBuffer sb1 = new StringBuffer(sb.reverse());
// String s1 =sb.toString();
// if(s.equals(s1)){
// System.out.println("字符串对称");
// }
// else{
// System.out.println("字符串不对称");
// }
//方法二：
char [] chs =s.toCharArray();
boolean flag = true;
int maxIndex = chs.length - 1;
for (int i = 0; i <chs.length; i++) {
if (chs[i]!=chs[maxIndex-i]) {
flag = false;
break;
}

}
System.out.println(flag);


}


}

2.从键盘输入10个数字,用冒泡排序进行从小到大的排序

package com.edu_01;


import java.util.Arrays;
import java.util.Scanner;


public class Test {
public static void main(String[] args) {
//2.从键盘输入10个数字,用冒泡排序进行从小到大的排序
//创建键盘录入对象，并导包
Scanner sc = new Scanner(System.in);
//创建一个数组
int[] arr = new int[10];
for (int i = 1; i < 11; i++) {
System.out.println("请输入第"+i+"个数字");
int a = sc.nextInt();
arr[i-1] = a;
}

//打印数组
System.out.println(Arrays.toString(arr));

}


}

3：把abcdefg反转成gfedcba

package com.edu_408;
//把abcdefg反转成gfedcba
public class Work5 {
public static void main(String[] args) {
String s ="abcdefg";
StringBuffer sb = new StringBuffer(s);
StringBuffer sb1 = new StringBuffer(sb.reverse());
String s2 =sb.toString();
System.out.println(s2);
}


}

4：有abasdcalsjdfasf34asfjsfasf一段字符串，找出其中重复最多的字符，和重复最少的字符和重复的次数！

package com.edu_403;


public class Work01 {
public static void main(String[] args) {
//2.有abasdcalsjdfasf34asfjsfasf一段字符串，
// 找出其中重复最多的字符，和重复最少的字符和重复的次数！
/**
* 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);
}
}
}


}