java数组04

java数组04

---

---

前言

---

一、数组的概述？

数组是相同数据类型的有效集合
数组描述的是相通类型的诺干个数据，安照一定的先后次序排列组合而成
每一个数组称为一个数组元素，每一个数组元素通过下表来获取访问

二、数组声明创建？

数组的元素是通过索引访问的 数组索引从0开始
获取数组长度 ann.length

语法：
数据类型[]  标识符;//声明 首选方法
或
数据类型 标识符[];//声明 效果相同但是不是首选方法

标识符=new 数据类型[空间大小]；//创建数组

int [] ann =new int[6];//合体
 

实例：

public class a{
   public static void main(String[] args)
       //声明  栈
       int [] ann;
       //创建  堆
       ann=new int[6];
       //赋值  堆
       ann[0]=1;
       ann[1]=2;
       ann[2]=3;
       ann[3]=4;
       ann[4]=5;
       ann[5]=6;
       //输出 length获取数组长度
       for (int i=0; i<ann.length;i++){
       System.out.println(ann[i])
       }
       
}

实例：

2.1内存分析

java内存
1.堆 ******** 1.存放new的对象和数组
**************2.可以被使用的线程共享，不会存放别的对象引用
2.栈 ******** 1.存放基本变量(会包含这个基本类型的具体数值)
**************2.引用对象的变量(会存放这个引用在堆里面的具体地址)
3.方法区 ***1.可以被所用线程共享
*************2.包含了所有的class和static变量

实例：

public class a{
   public static void main(String[] args)
       //声明  栈
       int [] ann;
       //创建  堆
       ann=new int[6];
       //赋值  堆
       ann[0]=1;
       ann[1]=2;
       ann[2]=3;
       ann[3]=4;
       ann[4]=5;
       ann[5]=6;
       //输出 length获取数组长度
       for (int i=0; i<ann.length;i++){
       System.out.println(ann[i])
       }
       
}

2.2数组三种初始化

静态初始化法

实例

int[] ann={1,2,3,4,5};
System.out.println(ann[0]);

动态初始化法

实例

 int [] ann;
 ann=new int[10];
 ann[0]=1;
 ann[1]=2;
 ann[2]=3;
 ann[3]=4;
 System.out.println(ann[2]);
 

数组的默认初始化
数组的引用类型 它的元素相当于类的实例变量 因此数组一经分配空间，其中的每一个元素也被按照实例变量同样的方式被隐式初始化
就是你数组的默认值和你定义的数组数据类型的默认值一样

根据数组的数据类型来定义默认值
如果 int [] ann=new int [];
默认就是0

实例

  int [] cnn=new int[10];
  //不赋值根据数组类型确定默认值
  System.out.println(cnn[4]);

2.3数组的4个基本特点

1.数组长度是确定的一旦被创建它的大小就不可改变
2.其数组元素的的类型必须是相同的不可以出现混合类型
3.数组可以是任何的数组类型 包括基本数据类型和引用类型
4.数组变量属于引用类型，数组也可以看成是对象，数组中的每一个元素相当于该对象的成员变量数组本身就是对象 java中对象在堆中， 因此数组无论保存原始类型还是对象类型，数组对象本身是在堆中的（意思就是定义的形式参数不会改变值的类型）

2.4数组常见错误（下标越界）

三、数组使用？

3.1普通的for循环

实例：

int [] ann={1,2,3,4,5};
//打印全部的数组元素
for(int i=0; i<ann.length;i++){
System.out.println(ann[i]);
}
//计算所有元素的和
int bnn=0;
for(int i=0;i<ann.length;i++){
bnn=bnn+ann[i];
}
System.out.println(bnn);
//查找最大元素
int cnn=ann[0];
for(int i=0;i<ann.length;i++){
  if(cnn<ann[i]){
  cnn=ann[i];
  }
}
System.out,println(cnn);

3.2for each 循环

  int[] ann={1,2,3,4,5};
  for(int a:ann){
  System.out.println(a);
  }

int[] ann={1,2,3,4,5};
int bnn=0;
for(int a:ann){
bnn=bnn+ann;
}
System.out.println(bnn);

3.3数组作为方法入参

public static void main(){
   int[] a={1,2,2,3,4,5};//静态数组
   ann(a);
   cnn(a);
}
//方法1
public static void ann(int[] a){
     for(int bnn:a){
     System.out.println(bnn);
     }
}

//方法2
public static void cnn(int[] a){
for(int i=a.length-1;i>=0;i--){
//数据的长度减一就是数组的下标长度
System.out.println(a[i]);
]

3.4数组作为返回值

四、多维数组？

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个维数组
二维数组

int[][] a=new int[2][5];

以上二维数组可以看成一个二行五列的数组

五、Arrays类？

数组的工具类java.util.Arrays
Arrays类都是静态的可以直接调用 对数组数据对象进行一系列的操作
Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不用"使用对象来调用(注意:是"不用"而不是“不能")

常用方法

1.fill 给数组赋值

Arrays.fill(Object[] array,Object object)可以为数组元素填充相同的值
Arrays.fill(Object[] array,int from,int to,Object object)对数组的部分元素填充一个值

实例

   int[] nums = {2,5,0,4,1,-10};
   Arrays.fill(nums);
   System.out.println(Arrays.toString(nums,0,4,1));
   或者
    System.out.println(Arrays.toString(nums,1));
   /*之前结果:[2,5,0,4,1,-10]
   * fill结果1:[1,1,1,1,1,-10]
   * fill结果2:[1,1,1,1,1,1]
   */

2. sort 按升序排序

Array.sort(Object[] array)
Arrays.sort(Object[] array, int from, int to)对数组元素指定范围进行排序

实例

   int[] nums = {2,5,0,4,1,-10};
   Arrays.sort(nums);
   System.out.println(Arrays.toString(nums));
   或者
   System.out.println(Arrays.toString(nums,0, 4));
   /*之前结果:[2,5,0,4,1,-10]
   * sort结果1:[-10,0,1,2,4,5]
   * sort结果2:[0,2,4,5,1,-10]
   */

3 .deepToString 返回多维数组的字符串形式

Arrays.deepToString(Object[][] arrays)返回多维数组的字符串形式

实例

int[][] nums = {{1,2},{3,4}};
        System.out.println(Arrays.deepToString(nums));
        /*
         * 结果:[[1, 2], [3, 4]]
         */

4. toString 返回数组的字符串形式

Arrays.toString(Object[] array)返回数组的字符串形式

实例

  int[] nums = {2,5,0,4,1,-10};
        System.out.println(Arrays.toString(nums));
        /*
         * 结果:[2, 5, 0, 4, 1, -10]
         */

equals 比较数组中元素是否相等

binarySearch 对排序好的数组进行二分查找法的操作查找数组元素

六、稀疏数组？

七、冒泡排序？

从小到大的排序

int[] a={1,3,2,5,7,6,9,8}
public static int[] Max(int[] a){
     int b=0;
for(int i=0; i<Max.length-1; i ++ ){//第一环的循环是循环多少次
   for(int x=0; x<Max.length-1; x++){//循环对比次数
        if(Max[x+1]<Max[x]){
        b=Max[x+1];
        Max[x+1]=Max[x];
        Max[x]=b;
        }
}
}
return a;