今天学习了多维数组的使用，并针对知识点做了大量的习题
引用数据类型
char[] arr=new char[26];
for(int i=0;i<arr.length;i++)
arr[i]=(char)('a'+i);
char[] brr=arr;//运行结果是变量brr和变量arr指代同一个位置
brr[brr.length-1]='\u9e00'; //修改brr中的内容实际上也修改了arr的内容
for(char temp:arr)
System.out.println(temp);
brr=arr意思是将arr所代表的复杂类型数据的地址传递给brr变量，结果是brr和arr变量使用的是同一个复杂类型数据，不管是brr修改或者arr修改，实际上修改是同一个数据，会发现一个修改，另外一个也同时发生变化
数组复制备份：注意这里不是地址值的复制，因为地址值的复制brr=arr，实际上两个变量引用的是同一个复杂类型数据。需要两个不同复杂类型数据，操作中不相互影响。使用循环作数组复制—克隆。
实现一个可变长的数组【Java中要求数组的长度是确定，一旦定义则不允许修改
/**
* 用于实现数组长度的自动增长
* @param arr 原始数组
* @param pos 需要添加数据的位置
* @param num 添加的数据
* @return 添加数据后的数组，有可能长度已经发生变化
*/
public static int[] changeLength(int[] arr,int pos,int num){
if(pos<arr.length){
arr[pos]=num;
return arr;
}else{
int newLength=arr.length*2;
if(pos>=newLength)
newLength=pos+1;
int[] res=new int[newLength];
for(int i=0;i<arr.length;i++)
res[i]=arr[i];
res[pos]=num;
return res; }
}
两种写法的比较：
方法1：优势在于避免频繁的值拷贝，但是有可能会有开辟出的没有用的空间
方法2：不要不断的进行变长，但是每次变长都会导致值拷贝的过程，所以比较浪费时间，优势在于用多少空间则开辟多少空间
数组的操作
length为数组对象的属性成员,可以直接使用【数组名称.length】获取数组长度。但是由于序号是从0开始，所以最大下标值为length-1，否则ArrayIndexOutOfBoundsException表示数组下标越界数组的长度一旦定义后，则不能改变。如果需要改变则需要重新创建数组
使用System类别所提供的arraycopy()方法
int[] arr1 = {1, 2, 3, 4, 5};int[] arr2 = new int[5];
System.arraycopy(arr1, 0, arr2, 0, arr1.length);参数含义为从arr1的第0个位置开始拷贝，拷贝到arr2的第0个位置开始，总共拷贝arr1.length个元素Java.lang.System类的静态方法arraycopy(Object源数组，int起始下标，Object目标数组，int目标起始下标，int长度) 如果源数组数目超过目标数组边界会抛出IndexOutOfBoundsException异常
int[] arr={
1,2,3,4,5};
int[] brr=new int[arr.length];
System.arraycopy(arr, 0, brr, 0, 3);
for(int temp:brr)
System.out.println(temp);
获取某个数组中的最小值
public class A2 {
public static void main(String[] args) {
//生成一个随机数的数组，长10
int[] arr=new int[10];
Random r=new Random();
for(int i=0;i<arr.length;i++)
arr[i]=r.nextInt();
System.out.println(arr);//[I@4e25154f 数组的直接输出格式
for(int temp:arr) //自定义输出数组中的每个元素
System.out.print(temp+"\t");
System.out.println(); //实现下次输出从头开始输出
int min=Integer.MAX_VALUE;
for(int i=0;i<arr.length;i++)
if(arr[i]<min)
min=arr[i];
System.out.println(min);
}
}
B哥去参加青年歌手大奖赛,有10个评委打分,(去掉一个最高一个最低)求平均分
public class A3 {
public static void main(String[] args) {
// 评委打分 0-10
Scanner sc = new Scanner(System.in);
double[] arr = new double[10];
for (int i = 0; i < arr.length; i++)
inputNum(arr, i, sc);
for (double temp : arr)
System.out.println(temp);
// 获取最值
double min = min(arr);
double max = max(arr);
//按照业务规则定义算法实现
double res=0;
for(double temp:arr)
res+=temp;
res-=min;
res-=max;
res/=8;
System.out.println("平均分："+res);
}
// 用于获取arr数组中的最大值
public static double max(double[] arr) {
double res = Double.MIN_VALUE;
if (arr != null) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] > res)
res = arr[i];
}
}
return res;
}
// 用于获取arr数组中的最小值
public static double min(double[] arr) {
double res = Double.MAX_VALUE;// 默认值为double类型的最大取值
if (arr != null) // 用于避免NullPointerException
for (int i = 0; i < arr.length; i++)
if (arr[i] < res res = arr[i];
return res;
}
//用于实现用户键盘录入评分，arr存储数据的数组，index是第几个评分，sc键盘
public static void inputNum(double[] arr, int index, Scanner sc) {
while (true) {
System.out.println("请打分：");
String ss = sc.nextLine();
try {
double d = Double.parseDouble(ss);
if (d >= 0 && d <= 10) {
arr[index] = d;
break;
}
System.out.println("输入的分数不合法！");
} catch (Exception e) {
System.out.println("输入数据格式不正确");
}
}
}
}
将指定数组中的数组元素进行反转,例如：{1,2,3,4,5} 反转{5,4,3,2,1}
int[] arr=new int[]{
1,2,3,4,5};
for(int i=0;i<arr.length/2;i++){
int temp=arr[i];
int pos2=arr.length-i-1;
arr[i]=arr[pos2];
arr[pos2]=temp;
}
包装类和Number
一般地当需要使用数字的时通常使用内置数据类型，如byte、int、long、double 等。然而在实际开发
过程中，经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一
个内置数据类型提供了对应的包装类。
所有的数值类型数据的包装类Integer、Long、Byte、Double、Float、Short都是抽象类 Number 的子类
byte–>Byte short–>Short int–>Integer long–>Long
float–>Float double–>Double
char–>Character
boolean–>Boolean
int k=100;
Integer k=100; 100是简单类型，但是可以直接赋值给复杂类型，装箱操作
int k1=k; k是复杂类型，但是可以直接赋值给简单类型，这是拆箱操作
这种由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类。相似的，编译器也可以把一个对象拆箱为内置类型。Number 类属于 java.lang 包
//输入是字串，如果进行数据类型转换
String ss="123";
int kk=Integer.parseInt(ss);//Integer kk=...
Integer k2=Integer.valueOf(ss);//int k2=..
//如果转换失败则报错，例如ss="123d"
//可以是具体数据类型转换为字串类型
//""+任意类型数据
字符串
字符串实际属于类，实际上所谓的字符串就是指一组字符的有序序列,可以使用双引号进行定义，属于复杂类型
字符串指的是字符的序列，有两种类型的字符串，可以使用3个不同的类进行定义
- 一种是创建以后不需要改变的，称为字符串常量，在Java中，String类用于存储和处理字符串常量
- 另外一种字符串是创建以后，需要对其进行改变的，称为字符串变量，在Java中StringBuilder/StringBuffer类用于存储和操作字符串变量
- 字符串有长度限制，在编译期要求字符串常量池中的常量不能超过65535，并且在javac执行过程中控制了最大值为65534。在运行期，长度不能超过Int的范围，否则会抛异常
String类型字串
字符串在Java中以String类别的一个实例存在
不可变immutable字符串。含义是一个字符串对象一旦被配置，它的内容就是固定不可变的（immutable）,如果需要进行修改则会引发对象的新建。不要以为下面的操作就是改变一个字符串对象的内容
Java为了提高字符串的处理效率，提供了一个池子，其中存放一些常用的字串。对于一些可以共享的字符串对象，会先在String池中查找是否存在相同的String内容
String s1="abc";
String s2=new String("abc");
System.out.println(s1==s2);//针对复杂类型==比较的是两个对象的地址值
System.out.println(s1.equals(s2));//比较的是具体内容
String s1 = "abc";
String s2 = "ab" + "c";
String s3 = new String("abc");
System.out.println(s1 == s2);//true常量池
System.out.println(s1 == s3);//false
System.out.println(s1.equals(s2));//true
System.out.println(s1.equals(s3));//true
Integer k1=726; //-128到127时==为真，因为常量池的存在
Integer k2=726;
System.out.println(k1==k2);
System.out.println(k1.equals(k2));
创建字串对象
new String（）空的字符串常量，例如String s=new String();
new String（String value）,例如Strings=new String(“abcd”);
new String（char value[]）例如char[] c=new char[]{
‘a’,’b’};String s=new
String(c);实际上就是创建一个字符串”ab”
new String（StringBuffer buffer）
字串的使用
字符串必须使用“”来包括您的文字,在Java中单双引号具有不同的含义，特别注意字符串的字符是使用Unicode字符来建构.字符串的串接在Java中可以直接使用’+/+=’，安装规则不允许重新定义运算符,但是Java重新定义了两个运算符.
String msg ="哈啰！";
msg = msg + "Java程序设计！";
System.out.println(msg);