传智播客旗下技术交流社区北京校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 金宏超 初级黑马   /  2019-1-11 21:01  /  52 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文


//1.1 数组的概念
        /*        概念:是一种容器,可以同时存放多个数据值
                特点:
                        1.一种引用数据.
                        2.数组当中的多个数据,类型必须统一.
                        3.数组运行期间,长度不能改变.
        */
        //1.2 数组的三种定义格式,一,动态初始化
        /*        数组的初始化:在内存当中创建一个数组,并且向其中赋予一些默认值/.
                常见的两种初始化方式(格式非常重要):
                        1.动态初始化(指定长度)
                        格式:数据类型[] 数组名称=new 数据类型[数组长度];
                        例:int[] arrayA=new int[10];
                       
                        数组左右两则的数据类型必须保持一致
        */
                       
        //1.3 二,静态初始化(指定内容)
        //                格式:1.数据类型[] 数组名称=new 数据类型[]{数组内容};
                       
        //1.4 静态初始化省略格式:
        /*                        数据类型[] 数组名称={内容};
                        例:int[] arrayA={5,10,15};
                        注意:静态初始化省略格式不能拆分.
                       
        //1.5 动态,静态初始化格式可以分为两个步骤:
                        int[] arrayA;
                                  arrayA=new int[num];
                               
                        int[] arrayA;
                                  arrayA=new int[]{a,b,c...};                               
        */
        //1.6 访问元素的获取
        /*        int array={10,20.30};
                System.out.println(array[0]);//[I@75412c2f//直接打印数组名称,得到的是数组对应的,内存地址哈希值.
                System.out.println(array[1]);
                System.out.println(array[2]);
               
                访问数组的格式:数组名称[索引值]               
                索引值:就是一个int数字,代表数组当中元素的编号
                注意:索引值从0开始,一直到数组的长度"-1"为止
               
               
                直接打印,也可以将数组当中的某一个元素赋值给变量
        */
       
        //1.7 访问数组元素的赋值
        /*       
                动态元素默认值:
                整数:0
                浮点:0.0
                字符:'\u0000'
                布尔:false
                引用:null
               
                int[] array=new int[3];
                array[1]=100;
                System.out.println(array[0]);
                System.out.println(array[1]);
                System.out.println(array[2]);                               
        */
       
        //1.8 数组的内存图
        /*        Java的内存划分
                栈(Stack):存放的都是方法中的局部变量
                        局部变量:方法的参数,或者是方法{}内部的变量
                        作用域:一旦超出作用域,立刻从栈内存当中消失
                       
                堆(Heap):凡是new出来的,都在堆当中.
                        堆内存当中的东西有一个地址值:16进制.
                        里面的数据都有默认值
                         动态元素默认值:
                                整数:0
                                浮点:0.0
                                字符:'\u0000'
                                布尔:false
                                引用:null
                               
                方法区(Method SArea):存储.class相关信息,包含方法的信息.               
                本地方法栈():与操作系统有关.
                寄存器:与CPU相关.
        */
       
        //1.9 一个数组的内存图,二个数组的内存图.
        /*       
        */
        //2.0 两个引用指向同一个数组
        /*        int[] arrayB=arrayA;
                改数组为将A数组赋值给B数组,两个引用指向同一个数组.数组内容可以更改.               
        */
       
        //2.1 数组的异常:数据索引的越界异常
        /*        如果访问数组元素的时候,索引编号并不存在,那么将会发生数组索引越界异常.
                原因:索引编号写错了.
                解决:修改成为正常存在的索引编号.
        */
       
        //2.2 空指针异常
        /*        数组必须进行new初始化才能使用其中的元素.
                如果只是赋值了一个null值,没有进行new创建,那么就会产生空指针异常.
                原因:忘了补new.
                解决:补回来.
        */
       
        //2.3 获取数组的长度
        /*        格式:数组名称.length;
                得到一个int数字,代表数组的长度.
               
                重点注意:数组一旦创建,程序运行期间,长度不可改变.               
        */
       
        //2.4 数组的遍历输出
        /*        遍历数组:对数组当中的每一个元素逐一,挨个处理.默认的处理方式就是打印输出.
         int[] array={1,3,4,5,6,7,7,8,8,8};
         for(int i=0;i<array.length;i++){//array.fori
                 System.out.println(array[i]);
         }
         
        */
       
        /*
        求数组的最值:
        int[] array={};
        int max=array[0];
        for(int i=1;i<array.length;i++){
                if(array[i]>max){
                        max=array[i];//该题型为求数组的最大值.相反if(array[i]<min)为求取数组的最小值.
                }
        }
        */
       
        /*
        数组元素反转;本来的样子反转之后.就是对称位置的元素交换.
        int[] array={a,b,c,d};
                {int min=array[0];
                int max=array.length-1;//当索引值min==max||min>max时停止交换,当min<max时需要交换.}//这里可以不写,下列for循环里直接写.
       
        for(int min=0,max=length-1;min<max;min++,max--){
                int temp=array[min];
                array[min]=array[max];
                array[max]=temp;
        }
        for(int i=0;i<arr.arr.length-1;i++){
                System.out.println(array[i]);
        }
        */
       
        /*
        数组作为方法参数,传递地址
       
        方法的多个返回值可以使用数组返回.
        int sum=a+b;
        int avg=sum/2;
        int[] array={sum,avg...};
        return array;
       
       
        public class Test05 {
    /* 定义一个数组如  {12,23,26,36,51,17,22,66,99}
      1.找出数组中能够被3整除的数据打印输出
      2.把那些能被3整除的数组组成新的数组并且遍历*/
    public static void main(String[] args) {
        int count = 0;
        int a = 0;

        int[] arr = {12, 23, 26, 36, 51, 17, 22, 66, 99};
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] % 3 == 0) {
                System.out.println(arr[i]);
                count++;

            }

        }
        int[] arr2 = new int[count];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] % 3 == 0) {
                arr2[a] = arr[i];
                a++;
                //遍历后的arr[i]数组元素编号为0,3,5...,而arr2[a]的元素编号是从0,1,2..顺序进行,
                // 所以这里要对应赋值,就是将arr[i]的0,3,5...,分别对应arr2[a]的元素编号0,1,2..
            }
        }
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        //该题型为易错题型,数组及新数组的遍历.
        }
分享至 : QQ空间
收藏

0 个回复

您需要登录后才可以回帖 登录 | 加入黑马