数组

今天主要学习了数组的使用，数字使用时是否会改变内部数值，通过一些练习和实例，还了解了多维数组。

1、循环打印出小写字母a~z

char c='a';
for(int i=0;i<26;i++)
 System.out.println((char)(c+i));
char[] arr=new char[26];
for(int i=0;i<26;i++)
 arr[i]=(char)(c+i);
//输出数组中的数据
for(int i=0;i<arr.length;i++)
    System.out.println(arr[i]);
//foreach结构，是用于遍历集合写法的语法糖，是for循环的简化写法
for(char temp:arr)
 System.out.println(temp);

2、将同一个对象指定给两个参考名称

public class A1 {
 public static void main(String[] args) {
 char[] arr = new char[26];
 for(int i=0;i<26;i++)
 arr[i]=(char)('a'+i);
 char[] brr=arr;
 for(int i=0;i<brr.length;i++) {
 brr[i]=Character.toUpperCase(brr[i]);
// if('a'<=brr[i] && brr[i]<='z') {
// char temp=(char)(brr[i]-'a'+'A');
// }
 }
 for(char temp:arr)
 System.out.println(temp);
 }
}

运行后则brr变量和arr变量都指向同一个数组，就是前面创建的数组，其中存放了26个字符的数组

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

做几个练习题，熟悉数组

1、获取某个数组中的最小值

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

2、菜哥去参加青年歌手大奖赛,有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("输入数据格式不正确");
 }
 }
 }
}

3、将指定数组中的数组元素进行反转

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

多维数组

• 针对数组中的元素类型没有特殊要求，所以允许数组的元素是数组。多维数组可以理解为数组的数组
• 数组中的每个数组元素可以是一个数组，但是不要求每个充当元素的数组长度一致

int[][] arr={{1,2,3,4,5},{3,4},{6,7,8,9}}; 二维数组
// System.out.println(arr.length); 获取第一维度的长度值，就是数组类型元素的
个数
// System.out.println(arr[0].length);获取第二维度的长度值，每个数组元素数组
可以等长，也可以变长
for(int[] temp:arr)
 System.out.println(temp);
for(int i=0;i<arr.length;i++){
 for(int k=0;k<arr[i].length;k++)
 System.out.printf("arr[%d][%d]=%d\t",i,k,arr[i][k]);
 System.out.println();
}

包装类和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"
可以是具体数据类型转换为字串类型
""+任意类型数据