JAVA学习笔记(五)- 数组

数组创建

数组

/*
 * 数组
 */
public class Test
{
    public static void main(String[] args)
    {
        int age;//声明
        age = 20;//赋值

//      int[] arrs;//声明了一个数组。array
//      int arrs2[];
//      float[] fs = new float[5];默认元素的值为0.0
//      char[] cs = new char[5];‘\u0000‘
//      String[] strs = new String[5];null

        //数组创建形式1
        //创建一个数组,且数组的长度为5.int[]表示数组元素为int类型数组。
        //此时,使用int类型的默认值,填充数组元素。
        int[] arrs1 = new int[5];

        //数组创建形式2
        //创建一个元素类型为int的数组,且长度为3
        //注意:此种形式不能指定数组长度
        int[] arrs2 = new int[]{1, 2, 3};

        //数组创建形式3
        //数组的静态创建形式。静态创建数组的形式不能先声明,再赋值
        //创建一个元素类型为int的数组对象,且数组长度为3
        int[] arrs3 = {3, 4, 5};

//      int[] arrs4;
//      arrs4 = {1, 2, 3};
        int[] arrs5;
        arrs5 = new int[5];
        int[] arrs6;
        arrs6 = new int[]{1, 2, 3, 4};
    }
}

数组的创建

/*
 * 数组的创建
 */
public class Test
{
    public static void main(String[] args)
    {
        //数组创建
        //特点:使用元素类型的默认值填充
        int[] arrs1 = new int[5];
        //特点:不指定数组的长度,数组的长度由{}中初始化的元素数决定
        int[] arrs2 = new int[]{1, 2, 3};
        //特点:静态创建数组,必须在声明的同时为其初始化。有{}中初始化的元素数决定数组长度
        int[] arrs3 = {1, 2, 3, 4, 5};

        //动态数组和静态数组
        //动态创建数组后,对于数组的名字可以重新赋值
        int[] arrs4;
        arrs4 = new int[5];

        //静态创建数组,则不能先声明,再创建
//      int[] arrs5;
//      arrs5 = {1, 2, 3};
//      arrs2 = {2, 3, 4};
        arrs3 = arrs1;

        String[] strs = new String[5];
    }
}

数组内存分析

数组的内存结构分析

/*
 * 基本数据类型和数组的内存结构分析
 *      Java中,数据的内存包含堆内存(heap)和栈内存(堆栈)(stack)
 */
public class Test
{
    public static void main(String[] args)
    {
        //如果为基本数据类型的变量,则直接在栈上分配内存,且值保存在栈中。
        int i = 10;
        i = 100;
        int j = i;

        //引用类型
        //引用数据类型,声明在栈上开辟内存空间,创建在堆上开辟一块内存空间,且真实值在堆上存储
        //通过=,将堆上开辟的内存空间,存放在声明的栈的内存中。
        int[] arrs = new int[5];
        //每次new的时候,都会在堆上重新分配内存空间
        arrs = new int[3];

        int[] arrs2 = arrs;

        arrs = new int[2];

        int[] arrs3 = null;

    }
}

操作数组

/*
 * 操作数组
 *  就是操作数组的元素,为元素赋值或者取得元素的值。
 */
public class Test
{
    public static void main(String[] args)
    {
        int[] arrs = new int[5];

        //获得数组的长度
        System.out.println(arrs.length);

        //通过索引,为数组中的元素赋值
        arrs[0] = 10;
        arrs[1] = 10;
        arrs[2] = 10;
        arrs[3] = 10;
        arrs[4] = 10;

        //通过索引,遍历数组中的值
        for(int index = 0; index < arrs.length; index++)
        {
            System.out.println(arrs[index]);
        }

        //如果使用数组下标超过了其表示的范围,则在运行的时候,会报
        //java.lang.ArrayIndexOutOfBoundsException
        System.out.println(arrs[arrs.length]);
    }
}

使用循环,为数组赋值,并遍历数组元素的值

/*
 * 使用循环,为数组赋值,并遍历数组元素的值
 */
public class Test
{
    public static void main(String[] args)
    {
        int[] arrs = new int[10];

        //使用循环,为数组赋值
        for(int i = 0; i < arrs.length; i++)
        {
            arrs[i] = i;
        }

        //使用循环,遍历数组
        for(int i = 0; i < arrs.length; i++)
        {
            System.out.println(arrs[i]);
        }
    }
}

实现数组的拷贝

/*
 * 实现数组的拷贝
 */
public class Test
{
    public static void main(String[] args)
    {
        //原数组
        int[] src = {1, 2, 3, 4, 5};

        //实现数组拷贝,必须有一个新数组
        int[] dest = new int[src.length];

        //将原数组中每个索引赋值给目标数组中对应的索引。
        for(int i = 0; i < src.length; i++)
        {
            dest[i] = src[i];
        }

        //遍历目标数组
        for(int i = 0; i < dest.length; i++)
        {
            System.out.println(dest[i]);
        }
    }
}

求数组中的最大值

/*
 * 求数组中的最大值
 */
public class Test
{
    public static void main(String[] args)
    {
        int[] arrs = {9, 2, 4, 9, 7, 1, 6};

        //定义一个变量,默认该变量中存放的值为最大值
        int max = arrs[0];

        //表示最大值的索引
        int maxIndex = 0;

        //循环数组
        for(int index = 1; index < arrs.length; index++)
        {
            if(arrs[max] < arrs[index])
            {
                max = arrs[index];
                maxIndex = index;
            }
        }

        System.out.println(max);
        System.out.println(maxIndex);
    }
}

练习:

/*
 * 题目:
 * int[] arrs = {8, 7, 9, 3, 5, 6, 1, 2};查找数组中是否包含5这个元素,
 * 如果不包含,则程序结束。如果包含,则在第一次5所在位置的前面,插入一个值,该值为10。
 */
public class Test
{
    public static void main(String[] args)
    {
        int[] arrs = {8, 7, 9, 3, 5, 6, 1, 2, 5};

        //1-先判断数组中是否存在5这个元素。如果不存在,则程序退出,如果存在,则返回第一次出现5的索引。

        //定义一个标识索引的变量,该变量如果为-1,则表示不包含5;如果不是-1,则包含5.
        int index = -1;

        //遍历数组,判断是否包含5,如果包含,则得到第一次出现5的索引
        for(int i = 0; i < arrs.length; i++)
        {
            //依次取得每个元素,判断是否等于5
            if(arrs[i] == 5)
            {
                //如果条件成立,则将5所在位置的索引赋值给index变量
                index = i;

                //因为取得的是第一次出现5的位置,所以,一旦出现5,则终止循环
                break;
            }
        }

        //2-通过index的值,判断是否包含5
        //此时如果index等于-1,表示数组中不包含5;否则,包含5.
        if(index != -1)
        {
            //此时,创建一个新数组,且该数组比arrs数组长度+1
            int[] newArrs = new int[arrs.length + 1];

            //将arrs数组中index索引位置前的元素,赋值给newArrs
            for(int i = 0; i < index; i++)
            {
                newArrs[i] = arrs[i];
            }

            //在5所在索引位置前,插入10.
            newArrs[index] = 10;

            //将arrs数组中index所在位置之后的元素,赋值给newArrs中index之后的元素
            for(int i = index; i < arrs.length; i++)
            {
                newArrs[i + 1] = arrs[i];
            }

            //将新数组赋值给原数组
            arrs = newArrs;
        }

        for(int i = 0; i < arrs.length; i++)
        {
            System.out.println(arrs[i]);
        }
    }
}
/*
 * 题目:
 * int[] arrs = {8, 7, 9, 3, 5, 6, 1, 2};查找数组中是否包含5这个元素,
 * 如果不包含,则程序结束。如果包含,将数组中5的位置修改成10
 */
public class Test
{
    public static void main(String[] args)
    {
        int[] arrs = {8, 7, 9, 3, 5, 6, 1, 2, 5};

        //1-先判断数组中是否存在5这个元素。如果不存在,则程序退出,如果存在,则返回第一次出现5的索引。

        //定义一个标识索引的变量,该变量如果为-1,则表示不包含5;如果不是-1,则包含5.
        int index = -1;

        //遍历数组,判断是否包含5,如果包含,则得到第一次出现5的索引
        for(int i = 0; i < arrs.length; i++)
        {
            //依次取得每个元素,判断是否等于5
            if(arrs[i] == 5)
            {
                //如果条件成立,则将5所在位置的索引赋值给index变量
                index = i;

                //因为取得的是第一次出现5的位置,所以,一旦出现5,则终止循环
                break;
            }
        }

        //2-通过index的值,判断是否包含5
        //此时如果index等于-1,表示数组中不包含5;否则,包含5.
        if(index != -1)
        {
            arrs[index] = 10;
        }

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

排序

冒泡排序

/*
 * 冒泡排序
 */
public class Test
{
    public static void main(String[] args)
    {
        int[] arrs = {8, 7, 9, 3, 5, 6, 1, 2};
        int[] arrs2 = {8, 7, 9, 3, 5, 6, 1, 2};
        for(int i = 0; i < arrs.length - 1; i++)
        {
            for(int j = 0; j < arrs.length -1 - i; j++)
            {
                if(arrs[j] > arrs[j + 1])
                {
                    int temp = arrs[j];
                    arrs[j] = arrs[j + 1];
                    arrs[j + 1] = temp;
                }
            }
        }

        Arrays.sort(arrs2);

        //foreach或增强for循环
        //JDK1.5之后。
        for(int i : arrs2)
        {
            System.out.print(i + "  ");
        }

    }
}

二维数组

二维数组的创建

/**
 *  二维数组
 */
public class Test
{
    public static void main(String[] args)
    {
        int[] arrs1 = {1, 2, 3, 4, 5};
        String[] arrs2 = {"aaa", "bbb", "ccc", "ddd"};

        //二维数组的创建:
        //1-表示arrs3对象是一个一维数组,且该一维数组的类型是int[],默认值为null;
        //arrs3.length值为3
        int[][] arrs3 = new int[3][];

        //2-表示arrs4是一个一维数组,且该数组元素的类型是int[],
        //3表示arrs4的长度,4表示arrs4中,每个元素(一维数组)的长度
        int[][] arrs4 = new int[3][4];

        //3-
        int[][] arrs5 = new int[][]{{1, 2}, {3}, {4, 5, 6, 7}};

        //4-
        int[][] arrs6 = {{1, 2}, {1, 1, 1, 1}, {1}, {2, 2}};

        System.out.println(arrs6.length);

        for(int[] arrs : arrs6)
        {
            System.out.println(arrs[0]);
        }
    }
}
public class Test
{
    public static void main(String[] args)
    {
        int[][] arrs = {{1, 1, 1}, {2, 2}, {3}, {4, 4, 4, 4, 4}};

        //该数组arrs的元素类型为int[],所以,其长度为int[]的个数
        System.out.println("数组的长度" + arrs.length);

        System.out.println(arrs[1][0]);

        //遍历数组
        for(int i = 0; i < arrs.length; i++)
        {
            for(int j = 0; j < arrs[i].length; j++)
            {
                System.out.print(arrs[i][j] + "\t");
            }

            System.out.println();
        }
    }
}
时间: 2024-08-24 14:08:14

JAVA学习笔记(五)- 数组的相关文章

Java学习笔记:数组

package myjava; /**  * 数组  * @author Administrator  *  */ import java.util.*; public class Myarray { public static void main(String args[]) { // 数组排序 int array[] = { 1, 9, 4, 2, 8, 6, 7 }; Arrays.sort(array); // 数组输出 for (int item : array) { System.o

java学习笔记六——数组

数组类型 数组是一种常见的数据结构,可用于存放多个数据,每一个数组元素存放一个数据,通常可以通过下标进行访问其元素. Java数组要求所有数组元素具有相同的数据类型.因此,数组元素的数据类型是唯一的. 数组定义如下: type[] arrayName; //推荐使用 type arrayName[]; //不推荐使用 通常我们都使用第一种方式.注意:数组的定义不能指定数组长度,只有在初始化时才指定长度. 数组初始化: int[] intArr = new int[]{1,2,3,4,5}; //

【原】Java学习笔记010 - 数组

1 package cn.temptation; 2 3 public class Sample01 { 4 public static void main(String[] args) { 5 // 需求:一堆分数,要统计最高分.最低分.总分.平均分 6 // int score1 = 80; 7 // int score2 = 70; 8 // int score3 = 90; 9 // int score4 = 65; 10 // // ... 11 // // 以计算平均分为例 12 /

黑马程序员----java学习笔记之数组、二维数组,附相关面试题

------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------- 一:数组(掌握) (1)数组:存储同一种数据类型的多个元素的容器. (2)特点:每一个元素都有编号,从0开始,最大编号是长度-1. 编号的专业叫法:索引 (3)定义格式 A:数据类型[] 数组名; B:数据类型 数组名[]; 推荐是用A方

Java学习笔记七——数组工具类Arrays

数组工具类Arrays Java提供的Arrays类里包含的一些static修饰的方法可以直接操作数组.若将里面的方法用熟的话,那开发效率会大大提高.下面介绍其中的方法. List<T> asList(T... a) 作用:将指定数组或数组元素,转换成固定大小的List. 用法: String[] strArr = { "aaa", "bbb", "vvv" }; //用法1:参数是数组引用 List<String> li

Java学习笔记五:复用类

当我们在使用第三方或者其他人已经写好的类时,通常有两种方法: (1).组合:在新的类中产生现有类的引用. (2).继承:按照现有类的类型创建新类.   1.组合 简单理解就是新类中,创建一个变量,变量的引用为现有类. 我们在很多场景下都是用到组合,如: public class Lesson_04_Extend { private Extend1 extend1; // 组合方式,创建成员变量(UML 组合关系) public void print(Extend1 extend2) // (UM

黑马程序员——JAVA学习笔记五(异常)

1,     异常:是在运行时期发生的不正常情况. 在java中用类的形式对不正常情况进行了描述和封装对象.描述不正常的情况的类,就称为异常类. 以前正常流程代码和问题处理代码相结合,现在将正常流程代码和问题处理代码分离,提高阅读性. 其实异常就是java通过面向对象的思想将问题封装成了对象,用异常类对其进行描述. 不同的问题用不同的类进行具体的描述.比如角标越界.空指针异常等等. 问题很多,意味着描述的类也很多,将其共性进行向上抽取,形成了异常体系. 不正常情况分成了两大类: Throwabl

Java学习笔记之数组

1.数组是引用数据类型,引用数据类型传递的是内存的使用权,是一块内存空间,它可以由多个单位同时使用.  而赋值的过程并不是把a数组内的数据传递给b,而是把a数组的内存使用权与b共享.所以当a和b共享同一个数组内存时,不管改变数组a内的值还是改变数组b内的值,该数组都会改变. 2.定义并初始化: 2.1 int[] arr; arr=new int[5]; for(int i=0;i<arr.length;i++) arr[i] = i; 2.2 int[] arr=new int[5]; for

Java学习笔记五(多线程)

1.介绍 线程能够使程序具有两条和两条以上的可执行的路径,尤其对多核CPU特别的重要. 2.创建线程 1.继承Thread类 一个类直接的继承Thread类的话,此类就具有了线程的能力,接下来只需要重写继承的run()即可. <span style="font-size:18px;">package com.Thread; //定义实现Runnable接口的类 class MyThread11 extends Thread { //实现run方法,指定线程执行的任务 pub