Java——一维数组

一维数组

一维数组定义：长度不可变的容器，且其存储的数据类型必须一致。格式：（如下）数组内存模型栈内存:堆内存:实例：数组的遍历——循环遍历输出数组数组的元素拷贝数组工具类常用方法：toString数组工具类常用方法：sort数组工具类常用方法：fill数组查找：binarySearch (二分查找)数组的排序算法——冒泡排序

定义：长度不可变的容器，且其存储的数据类型必须一致。

格式：（如下）

   //数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度]; 
 ​
 •        int[] arr = new int[3]; //动态初始化
 ​
 •        //数  据类型[] 数组名= new 数据类型[]{元素1,元素2,元素3...}; 
 ​
 •        int[] arr1 = new int[]{1,2,3,4,5}; //静态初始化                
 ​
 •        //数据类型[] 数组名= {元素1,元素2,元素3...}; 
 ​
 •        int[] arr2 = {1,2,3,4,5};

注意：数组长度允许为0

int [] a = null; 和 int []a = new int[0]; 是不同的

数组内存模型

一基本类型和弓|用类型存储的区别

● 基本数据类型的变量中存储的即为值本身 ●引用类型变量中存储的值指向了内存中另一个地方,通过这个“引用” 来访问该内存中的数据

栈内存:

栈内存首先是一片内存区域,存储的都是局部变量,凡是定义在方法中 的都是局部变量(方法外的是全局变量) , for循环内部定义的也是局部变量， 是先加载函数才能进行局部变量的定义,所以方法先进栈,然后再定义变量,变 量有自己的作用域,一旦离开作用域,变量就会被释放。栈内存的更新速度很快， 因为局部变量的生命周期都很短。

堆内存:

存储的是数组和对象(其实数组就是对象) , 凡是new建立的都是在堆 中,堆中存放的都是实体(对象),实体用于封装数据,而且是封装多个(实体 的多个属性) , 如果一个数据消失,这个实体也没有消失,还可以用,所以堆是 不会随时释放的,但是栈不一-样,栈里存放的都是单个变量,变量被释放了,那 就没有了。堆里的实体虽然不会被释放,但是会被当成垃圾，Java有垃圾回收机

总结：基本数据类型的变量中存储的即为值本身；

引用类型变量中存储的值指向了内存中另一个地方通过这个“引用”来访问该内存中的数据；

实例：

 public static void main(String[] args) {
         // TODO Auto-generated method stub
         int a = 10;
         int []b = {1,2,3,4,8};
         int []c = {1,2,3,4,5};
         fun(a);
         fun1(b);
         fun2(c);
         System.out.println(a);
         System.out.println(b[0]);
         System.out.println(c[0]);
     }
     public static void fun(int a) {
         a = 20;
     }
     public static void fun1(int []b) {
         b = new int[] {4,5,6,8,9};
 //      System.out.println(b[0]);
     }
     public static void fun2(int []c) {
         for (int i = 0; i < c.length; i++) {
             c[i]=0;
         }
     }

 //结果
 10
 1
 0

分析：

 

数组的遍历

——循环遍历输出数组

1.使用普通的for循环

 for(int i = 0;i<arr.length;i++){
     System.out.println(arr[i]+",");
 }

2.使用for-each循环

 for(int num : arr){
     System.out.println(num+",");
 }

数组的元素拷贝

——1.通过循环拷贝

 示例：从a数组的m号位置的元素将len个元素拷贝到b数组的n号开始后的元素上
 for(int i = m,j = n ;i<a.length && j<b.length && len > 0;i++,j++,len++){
  b[j] = a[i];
 }

——2.通过系统函数

 示例：从a数组的m号位置的元素将len个元素拷贝到b数组的n号开始后的元素上
 System.arraycopy(a,m,b,n,len);

数组工具类常用方法：toString

——将数组内容转换为字符串，格式为”[元素1，元素2，....]“

 示例
 int[]arr = {13,92,54,22,30,23};
 String str = Arrays.toString(arr);
 System.out.println(str);

 输出：
 [13,92,54,22,30,23]

数组工具类常用方法：sort

——将数组内容按照自然顺序进行升序排列

 int[]a = {47,77,83,7,43,93,15};
 Arrays.sort(a);
 System.oout.prngtln("对a数组整体排序后:"+Arrays.toString(a));
 int[]b = {80,17,84,78,33,13,10,30,68,91};
 Arrays.sort(b,3,8);//顾前不顾后
 System.out.println("对b数组部分排序后："+Arrays.toString(b));

 //输出
 对a数组整体排序后:[7,15,43,47,83,93]
 对b数组整体排序后:[80,17,84,10,13,30,33,78,68,91]

补充

——Arrays类对比较器（Comparartor）的支持---自定义排序

 //自定义比较器对象，只能支持引用类型的排序！
         Integer[] ages = {34,12,42,23};
         /*
         参数一：被排序的数组必须是引用类型的元素
         参数二：匿名内部类对象，代表了一个比较器对象
          */
         Arrays.sort(ages, new Comparator<Integer>() {
             @Override
             public int compare(Integer o1, Integer o2) {
                 //指定比较规则
                return o2 - o1;
             }
         });
         System.out.println(Arrays.toString(ages));

数组工具类常用方法：fill

——使用指定的数值填充数组元素，也可以指定填充的范围

 int[]a = {47,77,83,7,43,93,15};
 Arrays.fill(a,66);
 System.out.println("对a数组整体填充后："+Arrays.toString(a));
 int[]b = {80,17,84,78,33,13,10,30,68,91};
 Arrays.fill(b,3,8,66);//顾前不顾后
 System.out.println("对b数组整体填充后："+Arrays.toString(b));

 //输出
 对a数组整体填充后：[66,66,66,66,66,66,66]
 对b数组整体填充后：[80,17,84,66,66,66,66,66,68,91]

数组查找：binarySearch (二分查找)

——在数组(或指定的范围)中使用二分搜索法来搜索指定的值,如 果搜索到则返回其索引,如果没有搜索到,返回值为插入点-1 ( *插入点为第一个大于搜索目标的元素位置)</u> 注意: ●使用二分搜索法搜索的目标数组(或目标范围)必须先进行排序 ( Arrays.sort ) ●如果搜索目标中包含多个相同结果,无法保证找到的是哪一 个

 int[]a = {47,77,83,7,43,93,15};
 Arrays.sort(a);
 System.oout.prngtln("对a数组整体排序后:"+Arrays.toString(a));
 int index = Arrays.binarySearch(a,77);
 System.out.println("查找目标77结果是："+index);
 intdex = Arrays.binarySearch(a,78);
 System.out.println("查找目标78结果是："+index);

对a数组整体排序后:[7,15,43,47,77,83,93]
 查找目标77结果是：4
 查找目标78结果是：-6

数组的排序算法

——冒泡排序

算法步骤

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

图示：

算法实现：

 public class maopao {
     public static void main(String[] args) {
         int a [] = {12,36,11,43,23};
         for (int i = 0; i < a.length-1; i++) {
             for (int j = 0; j <a.length-i-1;j++) {
                 if (a[j]>a[j+1]) {
                     int temp = a[j];
                     a[j]=a[j+1];
                     a[j+1]=temp;
                 }
             }
         }
         //遍历输出
         for (int i = 0; i < a.length; i++) {
             System.out.print(a[i]+"\t");
         }
     }

——直接选择排序

算法步骤

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

重复第二步，直到所有元素均排序完毕。

图示：

算法实现：

 //定义数组
 int[] arr = {5,1,2,3};
 //           0 1 2 3
 //定义一个循环控制选择几轮
 for (int i = 0; i < arr.length-1; i++) {
     //定义内部循环控制选择几轮
     for (int j = i+1; j <arr.length; j++) {
                 if (arr[i]>arr[j]){
                    int temp = arr[i];
                     arr[i] = arr[j];
                     arr[j] = temp;
                 }
             }
         }  System.out.println(Arrays.toString(arr));
 }