JAVA学习笔记——第六章 数组

最新推荐文章于 2024-07-28 19:41:52 发布
最新推荐文章于 2024-07-28 19:41:52 发布
阅读量1.4k 收藏 24
点赞数 46
分类专栏： JAVA零基础开始 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/showy0/article/details/135755070
版权

🔥博客主页： A_SHOWY
🎥系列专栏：力扣刷题总结录 数据结构  云计算  数字图像处理  力扣每日一题_ 

数组可以存放多个同一类型的数据，是一种数据类型，是引用类型

即：数组就是一组数据

double total = 0;     
double[] hens = {1,2.1,3.2,5,6,7,9};
for(int i = 0; i < 7; i++){
total += hens[i];
System.println.out("total");
}

数组的长度：数组名.length。

数组的使用

使用方式1： 动态初始化

数组的定义：数据类型 数组名【】 = new 数据类型【大小】例：int a【】= new int【5】；

数组的引用（使用）： 数组名【index】 a【2】（获取第三个元素）

例：

import  java.util.Scanner;
public class shuzu1 {
    public static void main(String[] args){
      //输入
        double scores[] = new double[5];
       Scanner myscanner = new Scanner(System.in);
       for(int i = 0; i < scores.length;i++){
           System.out.println("请输入第" + (i+1) + "个元素的值");
           scores[i] = myscanner.nextDouble();
       }
       //输出
        for(int i = 0;i < scores.length;i++){
            System.out.println("第" + (i+1) + "个数组的元素是" + scores[i]);
        }
    }
}

使用方式2： 动态初始化

先声明数组：数据类型 数组名【】也可以   数据类型【】  数组名 例：int a【】或者int【】a

创建数组 ： 数组名 = new 数据类型【大小】 a = new int【10】

使用方式3： 静态初始化

初始化数组：数据类型数组名【】 =  {元素值，元素值。。。。}

数组的注意事项

  1. 数组是多个相同类型数据的组合，实现针对数据统一管理 
  2. 数组元素可以是任何数据类型，也可以放引用数据类型
  3. 数组创建后没有确定的值，有默认值：int：0，short：0，byte：0，long：0，float：0.0，double：0.0，char：0000，boolean：false，String： null
  4. 使用数组的步骤，先声明数组开辟空间，然后给各个元素赋值，最后使用
  5. 数组的下标从0开始，数组必须指定范围，不能越界
  6. 数组是引用类型，数组型数据是对象

例：

import  java.util.Scanner;
public class shuzu2 {
    public static void main(String[] args){
        //输入
     char[] chars = new char[26];
     for(int i = 0; i < chars.length;i++){
         chars[i] = (char)('A' + i);//'A' + i 是int类型，需要强制类型转换
     }
     //输出
        for(int i = 0; i < chars.length; i++){
            System.out.println(chars[i]);
        }
    }
}

 例2：

import  java.util.Scanner;
public class shuzu3 {
    public static void main(String[] args){
       int[] arr = {4,-1,9,10,23};
       int Max = arr[0];
       int index = 0;
       for(int i = 0; i< 5; i++){
           if(arr[i] > arr[index]){
               Max = arr[i];
               index = i;
           }
       }
       System.out.println(Max);
       System.out.println(index);
    }
}

 数组赋值机制

基本数据类型赋值的时候，这个值就是具体的数值且互不影响，赋值方式是值拷贝。而数组在默认情况下是引用传递，赋值是地址，赋值方式为为引用拷贝。

import  java.util.Scanner;
public class shuzu4 {
    public static void main(String[] args){
      int arr1[] = {1,2,3};
      int arr2[] = arr1;
      arr2[0] = 10;
      //看看arr1的值
        for(int i = 0; i < 3; i++){
            System.out.println(arr1[i]);
        }
    }
}

局部变量在栈内存，堆内放实例变量，方法区放静态变量，类方法

在内存里面只要分配了一个空间，一定会有一个地址

数组拷贝

 实现数组拷贝，进行一个内容的复制

      int arr1[] = {1,2,3};
      int arr2[] = arr1;
      int arr3[] = new int[arr1.length];//数组拷贝
      for(int i = 0; i < arr3.length; i++){
          arr1[i] = arr3[i];
      }

数组逆转 

import  java.util.Scanner;
public class shuzu5 {
    public static void main(String[] args){
        int arr[] = {11,22,33,44,55,66};
        int arr1[] = new int[arr.length];
        for(int i = arr.length -1, j = 0; i >= 0; i--, j++){
            arr1[j] = arr[i];
        }
        arr = arr1;//让arr1指向arr 的数据空间，arr原来的数据空间就没有变量引用，就会被当成垃圾销毁
        for(int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);
        }
     }
}

数组扩容

数组扩容整体是比较慢的，因为每次都要开辟一个新的空间

import  java.util.Scanner;
public class shuzu6 {
    public static void main(String[] args){
        Scanner myscanner = new Scanner(System.in);
        int arr1[] = {1,2,3};
//整体用一个do-while结构，先加一个，然后再问加不加
       do{
           int addarr[] = new int[arr1.length + 1];//每次添加都要开辟一个新空间，创建一个新数组
           System.out.println("请输入你想要添加的数字");
           int xin = myscanner.nextInt();
           for(int i = 0; i < arr1.length; i++){
               addarr[i] = arr1[i];
           }
           addarr[arr1.length] = xin;
           arr1 = addarr;
           //查看扩容后
           for(int i = 0; i < arr1.length; i++){
               System.out.println(arr1[i]);
           }
           System.out.println("请输入y/n表示是否还要增加元素");
           char a = myscanner.next().charAt(0);
           if(a == 'n') break;
       }
       while(true);
    }
}

冒泡排序

冒泡排序：通过对待排序列从后向前，依次比较相邻元素的值，若发现逆序则交换，使数值较大的元素逐渐从前移到后部。

思路：

  灵活的冒泡排序实现：

import  java.util.Scanner;
public class maopao {
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
       System.out.println("请输入想要排序的数组元素个数");
       int num = scanner.nextInt();
        int arr[] = new int[num];
//输入想要的数组的每一个元素
        for(int i = 0; i < num; i++){
            System.out.println("请输入第" + (i+1) +"个元素");
            int num1 = scanner.nextInt();
            arr[i] = num1;
        }
//外层代表循环次数
       for(int k = 1; k < num; k++) {
           for (int i = 0,j = 1; i <= (num - k - 1); i++, j++) {
               if (arr[i] > arr[j]) {
                   int temp = arr[i];
                   arr[i] = arr[j];
                   arr[j] = temp;
               }
           }
           System.out.print("==第" + k + "次循环==");
           for(int i = 0 ; i < num; i++){
               System.out.print(arr[i] + "  ");
           }
           System.out.println('\n');
       }

    }
}

 查找

1.顺序查找

2.二分查找：要求是有序的

二维数组

形式：int【包含几个一维数组】【每个一维数组包含几个元素】 ，二维数组可以理解为每一个元素都是一维数组

二维数组输出：

import java.util.Scanner;
public class erweishuzu {
    public static void main(String[] args){
      int a[][] = {{0,0,0,0,0,0},{0,0,1,0,0,0},{0,2,0,3,0,0},{0,0,0,0,0,0}};
      for(int i = 0; i < a.length; i++){
          for(int j = 0; j < a[i].length; j++){
              System.out.print(a[i][j]);
          }
          //换行
          System.out.println();
      }
    }
}

二维数组的使用

使用方式1：动态初始化   

类型【】【】 = new  类型 【大小】【大小】 例：int a【】【】=new int【2】【3】

 使用方式2：动态初始化 

先声明再初始化，和一维很类似

 使用方式3：动态初始化-列数不确定

import  java.util.Scanner;
public class shuzu7 {
    public static void main(String[] args){
       int[][] arr = new int[3][];//每个一维数组还没有开数据空间
       for(int  i = 0; i < arr.length; i++){//遍历每一个一维数组
           arr[i] = new int[i + 1];//给每一个一维数组开空间new
           for(int j = 0; j < arr[i].length; j++){//遍历每个一维数组，并给他们赋值
               arr[i][j] = i + 1;
           }
       }
    }
}

 使用方式4：静态初始化

和一维数组的非常相似 .

杨辉三角

杨辉三角就用到这种列数不确定

import  java.util.Scanner;
public class yanghui {
    public static void main(String[] args){
        int[][] yanghui= new int [5][];
        for(int i = 0; i < yanghui.length; i++){//遍历yanghui的每个元素
            //给每一个一维数组开辟空间
            yanghui[i] = new int[i + 1];
            //给每个一维数组赋值
            for(int j = 0; j < yanghui[i].length; j++){
                if(j == 0 || j == yanghui[i].length -1){
                    yanghui[i][j] = 1;
                }
                else{
                    yanghui[i][j] = yanghui[i - 1][j] + yanghui[i - 1][j - 1];
                }
            }
        }
        //输出
        for(int i = 0 ;i < yanghui.length;i++){
            for (int j = 0; j < yanghui[i].length; j++){
                System.out.print(yanghui[i][j] + "\t");
            }
            System.out.println();//空格
        }
    }
}

练习1：

 

 C选项之所以错了是可以理解为new的是一个String你初始化为{}是一个数组，所以不对。

练习2（重要）：

有两种思路，第一种是先扩容以后再冒泡排序

import  java.util.Scanner;
public class zuoye3 {
    public static void main(String[] args){
      int[] arr= {10,12,45,90};
      //先扩容
      int[] arr1 = new int[arr.length + 1];
      for(int i = 0; i <arr.length; ++i){
          arr1[i] = arr[i];
      }
      arr1[arr.length] = 23;
      arr = arr1;
      //再冒泡
        for(int k = 0 ; k < 4; k++) {
            for (int i = 0, j = 1; j <=arr.length -1; ++i,++j){
                if(arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
      for(int i = 0; i < arr.length;i++){
          System.out.print(arr[i] + "\t");
      }
    }
}

 第二种思路是先找到这个添加的地方，先定位，这个定位操作用到一个index = -1考虑到有可能插入到最后，然后进行插入

import  java.util.Scanner;
public class zuoye3_2 {
    public static void main(String[] args){
        int arr[] = {10,12,45,90};
        int insertNum = 23;
        int index = -1;
//先找index位置
        for(int i = 0; i < arr.length;i++){
            if(insertNum <= arr[i]){
                index = i;
                break;
            }
        }
//index可能是最大的
        if(index == -1){
            index = arr.length;
        }
//插入
        int arrnew[] = new int[arr.length + 1];
        for(int i = 0, j = 0;i < arrnew.length;i++){
            if(i != index){
                arrnew[i] = arr[j];
                j++;
            }
            else{
                arrnew[i] = insertNum;
            }
        }
        arr = arrnew;
//输出
        for(int i = 0; i < arr.length;i++){
            System.out.print(arr[i] + "\t");
        }
    }
}

A_SHOWY
关注
  • 46
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
JAVA学习笔记(六)-----数组
weixin_43356826的博客
03-02 188
数组(容器) 数组是一组数据类型相同的数据的组合，将这些数据统一的管理起来 数组本身是一个引用类型，数组内储存的类型可以是基本类型 也可以是引用类型 数组的特点 数组是一个引用数据类型 数组是在堆内存中的一串连续的地址存在 堆内存的数组空间长度一旦确定 不能再次发生改变 栈内存的变量中存储的是数组的地址引用 1.数组的定义(声明) 数据类型[] 数组名字; int[] x; ...
Java学习笔记 --- 第六章数组内容练习
乌云的博客
09-24 188
1
Java学习笔记——第二章 数组定义与使用
王小二1-2的博客
03-09 203
文章目录数组的出现Java 数组的定义与声明数组的优势与局限数组的扩容Arrays工具类的使用数组的遍历数组元素的选择排序数组元素的冒泡法排序多维数组 数组的出现 现在遇到这样一个问题，随机定义100个范围在100以内的int型变量，并输出这100个变量的值。 如直接定义并输入的话，会容易把人累死，此时为了能更加便捷（绝对不是为了偷懒！！），出现了数组，现将两种情况做个对比： 第一种情况（非常不可取！！！）： int a1 = 10 , a2 = 20 , a3 = 30 ,a4 = 55
Java学习笔记——Java中的数组
qq_63708623的博客
03-21 583
目录 数组的定义和创建 数组的初始化 Arrays类 数组是一种存储数据的结构。Java中的数组与C语言中的数组还是有很多不同的。 数组的定义和创建 int[] a; //定义一个数组a 通过int[] a我们可以定义一个int类型的数组a,但是此时，数组a是不可用的，因为以上步骤只对数组a进行了定义，告诉系统，a是一个int型的数组，却并没有为数组a在内存中开辟空间，数组没有被创建。那么我们接下来要创建一个数组。 a = new int[50]; //创建一个数组 通过以上步骤我
Java JDK 6学习笔记——ppt简体版 第21章.ppt
09-17
"Java JDK 6学习笔记——ppt简体版 第21章.ppt" 是一份关于Java Standard Edition 6（Java SE 6）新特性的讲解资料。在这个章节中，主要介绍了几个重要的更新，包括字符串处理、数组操作、日期与时间的国际化、以及...
学习笔记——资料
03-26
【Java学习笔记——全面解析】 Java作为一种广泛应用的高级编程语言，是软件开发领域的核心力量。这份"学习笔记——资料"涵盖了Java学习的各个方面，旨在帮助初学者和有经验的开发者巩固基础，提升技能。以下是对这...
Java 基础 第1阶段：基本语法-尚硅谷学习笔记（含面试题） 2023年
05-09
2023年的"Java 基础 第1阶段：基本语法——尚硅谷学习笔记（含面试题）"涵盖了从环境搭建到程序设计的基本要素，旨在帮助学习者系统地理解并应用Java语言。 一、Java环境搭建 在开始Java编程之前，你需要安装Java ...
java学习笔记－基础
12-23
### Java学习笔记——基础知识详解 #### 一、Java开发环境(JDK)与运行环境(JRE) Java技术的核心在于其强大的跨平台能力，这主要得益于Java的两大环境：JDK（Java Development Kit）和JRE（Java Runtime ...
Java JDK 6.0学习笔记
08-25
【Java JDK 6.0学习笔记】是一份详尽的文档，主要针对Java初学者，旨在帮助他们理解和掌握Java编程的基础知识。这份笔记基于Java 6.0版本，该版本在2006年12月初正式发布，尽管相较于之前的J2SE 5.0没有显著的变化，...
golang 接口
m0_70982551的博客
07-24 965
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 518
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 658
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 595
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 367
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 429
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
学习笔记---java篇（0723）
m0_70630166的博客
07-23 863
java、数据类型、循环、选择等
新建springboot项目找不到java版本8?
最新发布
weixin_74009895的博客
07-28 103
新建springboot项目找不到java版本8?
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 188
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
面向对象编程：Java学习笔记——类与对象设计原则
Java学习笔记主要聚焦于面向对象编程这一核心概念。面向对象编程（Object-Oriented Programming, OOP）是Java编程中的重要理论基础，它将现实世界中的事物抽象为对象，强调了对象的属性（属性描述了对象的状态）和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

A_SHOWY

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值