A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 温暖的小白   /  2015-5-12 22:18  /  6183 人查看  /  50 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

笔记内容:数组
笔记来源:刘意老实Java基础视频第4天
正文格式:
数组格式
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
示例:int[] arr = new int[5];通过new关键字创建了一个长度为5,元素类型是int的数组实体,并把这个数组实体赋值给引用类型变量 arr, 所以arr的类型是int[] (int类型数组)
会打印数组的内存地址(暂且这样记忆,之后会详细讲解),可以通过索引获取指定位置的元素


int [] arr = new int[5];

数据类型:
                 基本类型;4类8种。
                引用类型;类,借口,数组。

                左边;
                        int;表示数据类型。
                        [];表示这是一个数组
                        arr; 数组的名字。
               
                右边;
                        new;
                        int;表示数据类型。
                        [];表示一个数组
                        5;数组的长度

其他三种数组格式  A int[] arr =new int[2];//念法:int类型的数组arr
                  B int arr[] = new int[2];//念法:int 类型的arr数组,不推荐这么写,他和第一种格式其实一样的
                  C int[] arr = new int[]{1,2,3,7};//大括号内可以没有任何东西
                  D int[] arr = {3,4,65,4};//大括号内可以没有任何东西
                                 
                                  System.out.println(arr2) 是打印 arr2的十六进制字符
                                System.out.println(arr[2]) 是打印 堆中角标为3的元素


class Demo
{
                public static void main(String[] args)
        {
                        double[]  arr1 = new double[2];
                        int[] arr2 = new int[2];                //arr1 arr2 arr3就相当于变量x y z
                        char[] arr3 = new char[3]; //
                        boolean[] arr4 = new boolean[3];
                        System.out.println(arr2);
        }


}*/

/*
        需求:我要获取一个数据肿么办?
        通过索引(类似于字典的索引)。格式:数组名【索引】
                                                                        arr[0] arr[1]

       
        Java内存图:
                A:栈        存储局部变量使用。局部变量:定义在方法中或者方法声明上的形式参数都叫做局部变量
                        使用完毕,立马消失。

                B:堆        所有new出来的都在堆里面。
                        a:每一个实体都有地址值  本身是十进制,显示的是十六进制
                        b:每一个实体内的内容都有默认值
                                整数:0
                                浮点数:0.0
                                字符:'\u0000'
                                布尔:false
                        c:实体不再被使用的时候,在垃圾回收器空闲的时候被回收。

                C:方法区
                D:本地方法区
                E:寄存器
       
        需求:我要给第三个元素赋值为10,肿么办?
        arr[2]=10;    我说过了 arr[]  就相当于一个变量,[]里面装的是角标


****知识点:数组操作的常见问题
                       
                        A 数组越界  访问了不存在的索引,如下
                        ArrayIndexOutOfBoundsException

class Demo
{
        public static void main(String[] args)
        {
        int[] arr={1,2,3,4,2};

        System.out.println(arr[3]);
        System.out.println(arr[5]);//没有角标6的元素
        }
               
}
                        B 空指针异常。一个实例对象都已经不存在了,你还要访问
                                NullPointerException
                       
class Demo
{
        public static void main(String[] args)
        {
        int[] arr={1,2,3,4,2};

                arr=null;                                                //重新给arr赋值,以前是堆的地址值赋值给arr,
                                                                                                                现在是null赋值给arr,arr就不会通过 地址值指向堆
               
                System.out.println(arr[3]); //arr 已经是个空的了
        }
               
}
/*
知识点;多个数组指向同一个实例

class Demo
{
        public static void main(String[] args)
        {
                int[] arr=new int[3];
                arr[0]=1;
                arr[1]=3;
                arr[2]=5;

                int[] arr2=arr;        //再定义一个数组,把数组arr的值(地址值)付给了arr2                       
                arr2[1]=10;
               
                System.out.println(arr[1]);//10

                System.out.println(arr2[2]);//5
        }
                       
}       
*/
/*
   知识点; 遍历  获取数组中的所有元素

class Demo
{
        public static void main(String[] args)
        {
        int[] arr={1,2,3,4,5};

                System.out.println(arr[0]);
                System.out.println(arr[1]);
                System.out.println(arr[2]);
                System.out.println(arr[3]);
                System.out.println(arr[4]);
        }
               
}
   //通过循环改进,把所有数组中元素罗列出来

class Demo
{
        public static void main(String[] args)
        {
        int[] arr={1,2,3,4,5};

                for (int x=0;x<5;x++)                //x定义的是脚标 0 1 2 3 4
                {
                        System.out.println(arr[x]);
                }
        }
               
}
        //如果数据太多,就没办法了遍历么??
        //假如有人能够提供我们数组的长度,就可以做了(x<?)
        // java 提供了一个属性   length
                格式; 数组名.length
class Demo
{
        public static void main(String[] args)
        {
        int[] arr={1,2,3,4,5};

                for (int x=0;x<arr.length;x++)                //x定义的是脚标 0 1 2 3 4
                {
                        System.out.println(arr[x]);
                }
        }
               
}
                       
                需求;数组遍历  用方法
                思路   
                                返回值类型;void
                                参数列表;int[]arr



class Demo
{
        public static void main(String[] args)
        {
        int[] arr={1,2,3,4,5};
        int[] arr2={34,415,515,321,54,52,37,73,42};
        printArray(arr);    //执行一遍函数
                                                       
        printArray(arr2);        // 再执行一遍函数
        }
        public static void printArray(int[] arr)   // 传送数组  arr无所谓他和上面的arr1  arr2没有联系        其实传送的是空,直接就打印出来了        {
                        for (int x=0;x<arr.length;x++)                //x定义的是脚标 0 1 2 3 4
                        {
                                System.out.println(arr[x]);
                        }
                }
        }
                 
*/
/*
        需求,求数组中的最大值
        思路  
        1.需要进行比较,并且定义变量记住每次比较后较大的值
        2.对数组中的元素遍历取出,和变量记住的元素进行比较
                 如果遍历的元素大于变量中记录的元素,就用变量记住较大的值。
        3.遍历结果,该变量记住的就是最大值。

        定义一个功能实现

        明确1 结果。
                        是数组中的元素,int
        明确2 未知内容
                        数组



class Demo
{
        public static void main(String[] args)
        {
       
        int[] arr={34,415,515,321,54,52,37,73,42};
       
        int max = getMax(arr);  //先定义,在打印输出,这都错!!MD!!///?????????

        System.out.println(max);

       

        }
//方法1 定义元素
        public static int getMax(int[] arr)
                {   // 传送数组  arr无所谓他和上面的arr1  arr2没有联系                {
                        int max=arr[5];                                        //定义 int max=0  就是让每次循环中 元素跟0对比,
                                                                                                //假如元素中都是负数,那没就会输出最大值是0
                                                                                                //所以定义max 可以随意定义一个  数组中的任何一个元素

                                                                                                //初始化数组中的  元素 可以,那么初始化元素中的角标可不可以呢?怎么可以做到呢
                                                                                                //        可以,因为元素跟角标有着对应关系
                                                                               
                                                                                       
                        for (int x=0;x<arr.length;x++)                //x定义的是脚标 0 1 2 3 4
                        {
                                if (arr[x]>max)
                                {
                                        max=arr[x];                                        //每遍历一次数组中的元素都要循环做一次比较
                                }
                        }

                        return max;                                //错误忘了加分号
                }

// 方法2(定义角标)   运行方法2的时候需要把int max = getMax(arr);改成int max = getMax2(arr);

                        public static int getMax2(int[] arr)
                        {   
                        int maxIndex=0;                //初始化定义一个角标也可以,因为角标对应着元素               
                                                                                       
                        for (int x=0;x<arr.length;x++)                //x定义的是脚标 0 1 2 3 4
                        {
                                if (arr[x]>arr[maxIndex])                //元素跟角标对应的元素作对比
                                {
                                        maxIndex=x;                                        //
                                }
                        }

                        return arr[maxIndex];                                //错误忘了加分号
                        }
        }*/

回复 使用道具 举报
本帖最后由 wode1311 于 2015-7-31 22:44 编辑

笔记内容:数组的基础知识和应用
笔记来源:毕向东Java基础视频第5天
正文:
1、基础概念:     [url=]

          数组是存储多个同一类型数据元素的容器 , 数组中的元素会被自动从0开始编号,方便我们获取。

    分类:

       一维数组(4种定义格式):

                    int[] arr =new int[2];   

                    int arr[] = new int[2];         

                    int[] arr = new int[]{1,2,3,7};        //大括号内可以没有任何东西
                     int[] arr = {3,4,65,4};              //大括号内可以没有任何东西
       二维数组(三种定义格式):
                         第一种定义通过定义长度的方式定义了二维数组的长度,并且定义了一维数组的长度 int[][] arr = new int[6][3]
                         第二种定义通过长度仅定义了二维数组的长度,没有初始化一维数组int[] [] arr= new int[2][]
                         第三种定义通过直接给出元素定义了二维数组的长度和每一个一维数组的长度 int[][] arr = {{2,23},{33}}
2、数组操作:
                  1、数组遍历:

                          for(int i=0;i<arr.length;i++){

                                System.out.print(arr+"\t");

                            }

                                   

                  2、获取数组最值
                             public int getMax(int[] arr){
                                   int temp=arr[0];
                                   for(int i=1;i<arr.length;i++){
                                          if(arr>temp){
                                                temp=arr;

                                            }
                                   }
                                   return temp;
                             }
                  3、数组查找:给定一个值,查找该值在数组中对应的索引

                        public static int indexFirst(int[] arr, int num) {
                                for (int i = 0; i < arr.length; i++) {
                                          if (arr == num) {
                                                 return i;
                                          }
                                 }
                                return -1;
                       }

3、数组应用:



[/url]     1 、利用数组自定义一个可变长度的容器,可存储不同的数据。
  1. import java.util.Scanner;


  2. class Container {

  3. Object[] src;// 存放数据的数组

  4. /** 通过add方法将val添加到容器内 */
  5. public void add(Object val) {
  6. if (src != null) {
  7. Object[] arr1 = new Object[src.length + 1];
  8. for (int i = 0; i < src.length; i++) {
  9. arr1[i] = src[i];
  10. }
  11. arr1[src.length] = val;
  12. src = new Object[arr1.length];
  13. for (int i = 0; i < src.length; i++) {
  14. src[i] = arr1[i];
  15. }

  16. } else {
  17. src = new Object[1];
  18. src[0] = val;
  19. }

  20. }

  21. /** 通过给get方法传递一个索引,可以获取到该索引位置对应的值 */
  22. public Object get(int index) {
  23. return src[index];

  24. }

  25. /** 通过lenth()可以获取该容器中存储了多少个数据 */
  26. public int length() {
  27. return src.length;
  28. }

  29. }

  30. class Contain {

  31. public static void main(String[] args) {
  32. Container c = new Container();
  33. int tip;
  34. Object o;

  35. while (true) {
  36. System.out.println("请输入一个数据(1整型2浮点型3布尔型4字符串0停止):");
  37. Scanner sc = new Scanner(System.in);
  38. tip = sc.nextInt();
  39. if (tip == 0) {
  40. break;
  41. } else {
  42. o = setContent(tip);
  43. c.add(o);
  44. }
  45. }
  46. for (int i = 0; i < c.length(); i++) {
  47. System.out.println("第" + i + "个数据是:" + c.get(i));
  48. }
  49. System.out.println("共有" + c.length() + "个数据");
  50. }

  51. public static Object setContent(int tip) {
  52. Scanner sc = new Scanner(System.in);
  53. int i;
  54. double d;
  55. boolean b;
  56. String s;
  57. Object o = null;

  58. while (true) {
  59. if (tip == 1) {
  60. i = sc.nextInt();
  61. o = i;
  62. break;
  63. } else if (tip == 2) {
  64. d = sc.nextDouble();
  65. o = d;
  66. break;
  67. } else if (tip == 3) {
  68. b = sc.nextBoolean();
  69. o = b;
  70. break;
  71. } else if (tip == 4) {
  72. s = sc.next().toString();
  73. o = s;
  74. break;
  75. } else {
  76. System.out.println("输入非法数据,请重新输入...");
  77. break;
  78. }
  79. }

  80. return o;
  81. }

  82. }
复制代码

    2、数组拷贝,获取数据在数组中的位置,以及从某个位置开始获取某个元素的相对位置
  1. public static void main(String[] args)
  2. {
  3. int[] a=new int[]{1,2,3,4,5,8,5};
  4. int[] b=new int[a.length];
  5. ArrayCopy(a,b);

  6. char[] c=new char[]{'a','b','c','d','e'};
  7. char d='d';
  8. int location=indexOf(c,d);
  9. System.out.println(d+"在字符数组中的位置是第"+(location+1)+"个元素");

  10. char[] arr=new char[]{'1','2','3','4','6','9'};
  11. int position=indexOf(arr,2,'4');
  12. System.out.println("从第二个位置开始,4所在的位置是第"+position+"个元素");


  13. }

  14. //数组拷贝
  15. public static void ArrayCopy(int[] a,int[] b){
  16. for(int i=0;i<a.length;i++){
  17. b[i]=a[i];
  18. }
  19. }

  20. //获取元素位置
  21. public static int indexOf(char[] chs, char ch){
  22. for(int i=0;i<chs.length;i++){
  23. if(chs[i]==ch){
  24. return i;
  25. }
  26. }
  27. return -1;
  28. }

  29. //获取元素的相对位置
  30. public static int indexOf(char[] chs,int startIndex,char ch){
  31. int count=1;
  32. for(int i=startIndex-1;i<chs.length;i++){
  33. if(chs[i]==ch){
  34. return count;
  35. }
  36. count++;
  37. }
  38. return -1;
  39. }
复制代码

3 、房间案例 (二维数组):      一栋楼有7层,每层有10个房间,那么就把大楼看成一个二维数组,里面的每层是一维数组。

  1. class RoomDemo
  2. {
  3. public static void main(String[] args)
  4. {
  5. int[][] room = new int[7][10];
  6. for(int i=0; i<room.length; i++)
  7. {
  8. int[] floor = room[i];
  9. for(int j=0; j<floor.length; j++)
  10. {
  11. System.out.println("正在第"+(i+1)+"层中的第"+(j+1)+"个房间");
  12. }
  13. }
  14. }
  15. }
复制代码






回复 使用道具 举报
一、数组【掌握】
        1、数组:存储同一种数据类型的多个元素的容器。

        2、特点:每一个元素都有一个编号,从0开始,最大编号是数组长度 - 1。
                这个编号的专业叫法:索引。

        3、格式:
                (1)动态初始化
                        只指定长度,由系统给出初始化值
                        A:int[] arr = new int[3];
                        //B:int arr[] = new int[3];

                (2)静态初始化
                        给出初始化值,由系统计算长度
                        A:int[] arr = {1,2,3};
                        //B:int[] arr = new int[]{1,2,3};

                两种初始化都推荐A方案

        4、Java内存图:
                A:栈        存储局部变量; 方法在栈里面调用(压栈)
                        局部变量:定义在方法声明上和方法中的变量
                        方法调用完毕会弹栈,方法内部的局部变量也随之消失。

                B:堆        所有new出来的都在堆内存里面。
                        a:每一个对象都有地址值
                        b:堆内存里面每一个基本数据类型的变量都有默认值
                                整数:0                byte, short, int
                                浮点数:0.0        float, double
                                字符:'\u0000'        char
                                布尔:false        boolean

                C:方法区(面向对象部分讲解)
                D:本地方法区(和系统相关)
                E:寄存器(CPU使用)

        5、数组内存图
                A:一个数组
                B:二个数组
                C:三个数组(两个栈里面的局部变量指向同一个堆内存)

        6、常见操作:【重点掌握】
                A:遍历
                        方式1:
                                public static void printArray(int[] arr) {
                                        for(int x=0; x<arr.length; x++) {
                                                System.out.println(arr[x]);
                                        }
                                }
                               
                        方式2:
                                public static void printArray(int[] arr) {
                                        System.out.print("[");
                                        for(int x=0; x<arr.length; x++) {
                                                if(x == arr.length-1) {
                                                        System.out.println(arr[x]+"]");
                                                } else {
                                                        System.out.println(arr[x]+", ");
                                                }
                                        }
                                }

                B:最值
                        最大值:
                                public static int getMax(int[] arr) {
                                        int max = arr[0];
                                        for(int x=1; x<arr.length; x++) {
                                                if(arr[x] > max) {
                                                        max = arr[x];
                                                }
                                        }
                                        return max;
                                }
                       
                C:反转
                        方式1:
                                public static void reverseArray(int[] arr) {
                                        for(int i=0; i<arr.length/2; i++) {
                                                int temp = arr[i];
                                                arr[i] = arr[arr.length-1-i];
                                                arr[arr.length-1-i] = temp;
                                        }
                                }
                               
                        方式2:
                                public static void reverseArray(int[] arr) {
                                        for(int start=0,end=arr.length-1; start<=end; start++,end--) {
                                                int temp = arr[start];
                                                arr[start] = arr[end];
                                                arr[end] = temp;
                                        }
                                }

                D:查表
                        public static String getString(String[] strArray, int index) {
                                return strArray[index];
                        }

                E:基本查找
                        public static int getIndex(int[] arr,int value) {
                                for(int x=0; x<arr.length; x++) {
                                        if(arr[x] == value) {
                                                return x;
                                        }
                                }
                                return -1;
                        }


        7、二维数组 【理解】
                格式:
                        A:int[][] arr = new int[3][2];           //有三个一位数组,每个一维数组里面有2个int元素。
                        B:int[][] arr = new int[3][];
                        C:int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};

                遍历:
                        public static void print(int[][] arr) {
                                for (int i = 0; i < arr.length; i++) {
                                        for (int j = 0; j < arr[i].length; j++) {
                                                System.out.println(arr[i][j]);
                                        }
                                }
                        }
               
                求和:
                        public static int getSum(int[][] arr) {
                                int sum = 0;
                                for (int i = 0; i < arr.length; i++) {
                                        for (int j = 0; j < arr[i].length; j++) {
                                                sum += arr[i][j]
                                        }
                                }
                                return sum;
                        }

二、参数传递【掌握】
        public static void main(String[] args) {
                int a = 10;
                int b = 20;
                change(a, b);
                System.out.println("a=" + a + ", b=" + b);        //a=10, b=20

                int[] arr = {1,2,3,4,5};
                change(arr);
                System.out.println(arr[1]);           //arr[1] = 4;
        }

        public static void change(int a, int b) {
                a = b;
                b = a + b;
        }

        public static void change(int[] arr) {
                for(int x=0; x<arr.length; x++) {
                        if(arr[x]%2 == 0) {
                                arr[x] *= 2;
                        }
                }
        }

        结论:
        基本数据类型的值传递,不改变原值,因为方法在栈里面调用,调用完毕后方法会弹栈,局部变量也随之消失;
        引用数据类型的值传递,改变原值,因为即使方法弹栈,但是堆内存数组对象还在,可以通过地址继续访问

        简单记:
                A: 基本数据类型作为方法参数传递时,形参的改变不影响实参;
                B:引用数据类型(数组,类,接口)作为参数传递时,形参的改变影响实参。


        面试题:Java中到底是传值还是传址
                A:既是传值,也是传地址,基本数据类型传递的值,引用数据类型传递的地址
                B:java中只有传值,因为地址值也是值【出去面试都说这种,支持者是高司令(java之父)】
回复 使用道具 举报
~~~~~~~~~~~~~~
回复 使用道具 举报
、、、、、、、、、、、、、、
回复 使用道具 举报
本帖最后由 枫烬 于 2015-11-6 00:56 编辑

笔记内容:数组
笔记来源:冯佳Java基础视频第6天
正文:
            

概述


  • 数组是存储同一种数据类型多个元素的集合/容器,可以存储基本数据类型或是引用数据类型。
  • 数据类型[]  数组名 = new 数据类型[数组长度];
[]的个数代表数组的维度

  • 特点:


    • 数组的每个元素都有编号(index,索引,角标),从0开始,最大编号为arr.length-1
    • 在堆内存里面是一块连续的内存空间
  • 初始化:不允许动静结合


    • 动态初始化,指定长度,系统给出初始化值
    • 静态初始化,指定初始化值,系统来决定长度

默认初始化值:
  
整数类型
  
  
byte,short,int,long
  
  
0
  
  
浮点类型
  
  
float,double
  
  
0.0
  
  
布尔类型
  
  
boolean
  
  
false
  
  
字符类型
  
  
char
  
  
'\u0000'
  
  
引用数据类型  
  
  
  
  
null
  


‘\u0000’:每个0都是代表16进制的0

Sys.out.print(arr); ==>[I@da6

内存


  • 内存区块:
  
  
  
存储局部变量
  
  
先进后出
  
  
  
  
存储new出来的数组或对象
  
  
  
  
方法区
  
  
存储代码
  
  
  
  
本地方法区
  
  
和系统有关
  
  
  
  
寄存器
  
  
cpu用
  
  
  


局部变量:定义在方法声明和方法体里的变量

类文件运行加载后,主方法main以栈针的形式压栈到栈底,定义数组,在堆创建数组的连续空间



  • 异常


    • ArrayIndexOutOfBoundsException      数组索引越界异常
    • NullPointerException空指针异常

操作


  • 遍历

  1. //遍历数组
  2.         public static void testArray01(int[] arr){
  3.                 for (int i = 0;i < arr.length ;i++ ) {
  4.                         System.out.print(arr[i]+"\t");
  5.                 }
  6.                 System.out.println();
  7.         }
复制代码


  • 最大值
    1. //获取数组最大值
    2.         public static void getArrayMax(int[] arr){
    3.                 int max = arr[0];
    4.                 for (int i = 1;i<arr.length ;i++) {
    5.                         if (max < arr[i]) {
    6.                                 max = arr[i];
    7.                         }
    8.                 }
    9.                 System.out.println("最大值为:"+max+"。");
    10.         
    11.         }
    复制代码

  • 最小值
    1. //获取最小值
    2.         public static int getArrayMin(int[] arr) {
    3.                 int min = arr[0];
    4.                 for (int i = 1;i <arr.length ;i++ ) {
    5.                         if (min > arr[i]) {
    6.                                 min = arr[i];
    7.                         }
    8.                 }
    9.                 return min;
    10.         }
    复制代码

  • 反转
    1. //反转
    2.         public static void reverseArray(int[] arr) {
    3.                 for (int i = 0;i < arr.length/2 ;i++ ) {
    4.                         int temp = arr[i];
    5.                         arr[i] = arr[arr.length-i-1];
    6.                         arr[arr.length-i-1] = temp;
    7.                 }
    8.         }
    复制代码

  • 排序
  • 由值返回角标
    1. //由值返回角标
    2.         public static int getIndex(int[] arr,int value) {
    3.                 for (int i = 0;i < arr.length ;i++) {
    4.                         if (arr[i] == value) {
    5.                                 return i;
    6.                         }
    7.                 }
    8.                 return -1;
    9.         }
    10. }
    复制代码

  • 由角标返回值
    1. //星期
    2.         public static void getWeek(int week){
    3.                 char[] weekDay = {'一','二','三','四','五','六','日'};
    4.                 System.out.println("这是星期"+weekDay[week-1]+"。");
    5.                
    6.         }
    复制代码





二维数组

数据类型[ ][ ] 数组名称 = new 数据类型[ a ][ b];
==》a个一维数组,每个一维数组中有b个元素

Int[]x,y[];      x是一维数组,y是二维数组;

默认初始化值是null
参数传递问题:
基本类型数据的值传递,不改变原值,因为调用后会弹栈,局部变量消失。调用时,用的只是将变量的值赋给局部变量。
引用数据类型的值传递,改变原值,因为即使方法弹栈,但堆内存数组对象还在,可通过地址访问

java传值/传址?
只有传值,因为地址值也是值

形参的改变会影响实参吗?
基本数据类型,形参的改变不影响实参
引用数据类型,形参的改变影响实参







回复 使用道具 举报
我用的onenote做的笔记,复制过来之后格式就难看了==!!!
回复 使用道具 举报
123
您需要登录后才可以回帖 登录 | 加入黑马