JAVA笔记06 数组

最新推荐文章于 2023-09-01 17:29:12 发布
最新推荐文章于 2023-09-01 17:29:12 发布
阅读量96 收藏
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53334593/article/details/113064040
版权
数组的定义

数组是Java提供的一种最简单的数据结构，可以用来存储一个元素 个数固定 且 类型相同的有序
集。主要用于解决大量数据计算与存储的问题。
数组在内存中的情况
栈：主要用于运行函数的内存
堆：主要用于存储数据对象的内存
每一个数组而言，都是存在堆内存当中，每一个数组都是一个对象。
*数组本质上就是在堆内存中一系列地址连续且空间大小相等的存储空间（变量），每一个存
储空间用来存储数据（基本，引用）
数组是在堆内存中存储，称之为是一个对数对象，并且在堆内存中存储的数据都有 默认初始
化 的流程。所以数组创建之初，每一个存储空间里面都会被JVM初始化该数据类型对应的零值。
数组的地址是连续的，所以通过公式：An=A1+(n-1)d可以快速访问到其他的元素，所以对于
数组而言查找元素比较快的。将元素的真实物理地址转换成对应的角标获取元素。
如何来调用数组呢？通过一个变量存储该数组在堆内存当中的首元素的地址。
当数组一旦定义出来，其长度不可变，存储空间的内容是可变的
所以我们在定义数组的时候，要么把长度固定，要么直接输入相关的元素。
数组的定义方式：

//创建一个指定长度且指定数据类型的一维数组，名称为数组名，虽然没有指定元素，但是会有默认值
数据类型[] 数组名 = new 数据类型[长度];
//创建一个指定元素且指定数据类型的一维数组，名称为数组名，虽然有指定元素，还是有默认初始化这个步骤的！
数据类型[] 数组名 = new 数据类型[]{数据1,数据2,...,数据n};
数据类型[] 数组名 = {数据1,数据2,...,数据n};

例题：

public class Sample {
  public static void main(String[] args) {
    int[] arr = new int[5];
    System.out.println(arr[0]);
    //System.out.println(arr[5]);
    //ArrayIndexOutOfBoundsException
    arr[2] = 10;
    int[] arr2 = arr;
    System.out.println(arr2[2]);
    arr2 = null;
    //System.out.println(arr2[2]);
    //NullPointerException
    /*
    String s = null;
    s.length();
    */
    arr = null;
 }
}
常用数组操作
  1. 数组遍历问题
public class Sample {
  public static void main(String[] args) {
    int[] arr = new int[]{1,2,3,4,5,6,7,8,9};
    //String str str.length()-函数
    //int[] arr arr.length-属性
    for (int i = 0; i < arr.length; i++) {
      arr[i] = arr[i] * 10;
      System.out.println(arr[i]);
   }
    //通过角标遍历 可以在遍历的过程中对指定的元素进行修改
    //foreach遍历 主要针对的是一些可迭代对象 Iterable
    /*
    for (数据类型 变量名 : 可迭代容器) {
    }
    */
    for (int num : arr) {
      //num -> arr[i]
      num = num / 10;
      System.out.println(num);
   }
    //这种遍历方式 只能获取元素，不能修改元素
    for (int i = 0; i < arr.length; i++) {
      System.out.println(arr[i]);
   }
 }
}
  1. 数组最值问题
public class Sample {
  public static void main(String[] args) {
    int[] arr = new int[]{3,6,8,2,9,4,5,1,7};
    int min = arr[0];
    int max = arr[0];
    for (int i = 1; i < arr.length; i++) {
      if (arr[i] < min) {
        min = arr[i];
     }
      if (arr[i] > max) {
        max = arr[i];
     }
   }
    System.out.println(max);
    System.out.println(min);
 }
}
  1. 数组扩容问题
public class Sample {
  public static void main(String[] args) {
    int[] arr = new int[]{1,2,3,4,5};
        arr = add(arr,6);
    arr = add(arr,6);
    arr = add(arr,6);
    arr = add(arr,6);
    for (int i = 0; i < arr.length; i++) {
      System.out.println(arr[i]);
   }
 }
  //在指定的数组arr中添加元素element
  public static int[] add(int[] arr, int element) {
    int[] newArr = new int[arr.length + 1];
    for (int i = 0; i < arr.length; i++) {
      newArr[i] = arr[i];
   }
    newArr[newArr.length - 1] = element;
    return newArr;
 }
}
  1. 选择排序算法
public class Sample {
  //选择排序
  public static void main(String[] args) {
    int[] arr = {8,9,2,6,7,1,4,5,3};
    for (int i = 0; i < arr.length - 1; i++) {  //-1 n个数字没有第n轮
      for (int j = i + 1; j < arr.length; j++) {
        if (arr[i] > arr[j]) {
          swap(arr,i,j);
       }
     }
   }
    print(arr);
 }
  //[1, 2, 3, 4, 5]
  public static void print(int[] arr) {
    System.out.print("[");
    for (int i = 0; i < arr.length;i++) {
      System.out.print(arr[i]);
      if (i == arr.length - 1) {
        System.out.println("]");
     } else {
             System.out.print(", ");
     }
   }
 }
  public static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
 }
}
  1. 冒泡排序算法
public class Sample {
  //冒泡排序
  public static void main(String[] args) {
    int[] arr = {8,9,2,6,7,1,4,5,3};
   
    for (int i = 0; i <arr.length - 1; i++) {//-1 表示n个数字只有n-1轮
      for (int j = 0; j < arr.length - 1 - i; j++) {//-1 避免重复比较(当前最大和上一
轮最大)
        if (arr[j] > arr[j + 1]) {
          swap(arr,j,j+1);
       }
     }
   }
    print(arr);
 }
  public static void print(int[] arr) {
    System.out.print("[");
    for (int i = 0; i < arr.length;i++) {
      System.out.print(arr[i]);
      if (i == arr.length - 1) {
        System.out.println("]");
     } else {
        System.out.print(", ");
     }
   }
 }
  public static void swap(int[] arr, int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
 }
}
  1. 插入排序算法
public class Sample {
  //插入排序
  public static void main(String[] args) {
    int[] arr = {8,9,2,6,7,1,4,5,3};
    for (int i = 1; i < arr.length; i++) {
      int e = arr[i];
      int j = 0;
      for (j = i; j > 0 && arr[j - 1] > e; j--) {
        arr[j] = arr[j - 1];
     }
      arr[j] = e;
   }
    print(arr);
 }
  public static void print(int[] arr) {
    System.out.print("[");
    for (int i = 0; i < arr.length;i++) {
      System.out.print(arr[i]);
      if (i == arr.length - 1) {
        System.out.println("]");
     } else {
        System.out.print(", ");
     }
   }
 }
}
  1. 计数排序算法
public class Sample {
  //计数排序
  public static void main(String[] args) {
    int[] arr = {-2,9,-1,12,8,-3,6,7,4,5,2,1,0,8,6,7,4,-3,-2,-1,-1,7};
    int min = arr[0];
     int max = arr[0];
    //O(n)
    for (int i = 1; i < arr.length; i++) {
      if (arr[i] < min) {
        min = arr[i];
     }
      if (arr[i] > max) {
        max = arr[i];
     }
   }
    int[] temp = new int[max - min + 1];
    //对应关系 index = number - min  number = index + min
    //O(n)
    for (int i = 0; i < arr.length; i++) {
      temp[arr[i] - min]++;
   }
    //temp[index] 表示index对应的数字number出现的次数
    int k = 0;
    //O(n)
    for (int index = 0; index < temp.length; index++) {
      while (temp[index] != 0) {
        arr[k] = index + min;
        k++;
        temp[index]--;
     }
   }
    print(arr);
 }
  public static void print(int[] arr) {
    System.out.print("[");
    for (int i = 0; i < arr.length;i++) {
      System.out.print(arr[i]);
      if (i == arr.length - 1) {
        System.out.println("]");
     } else {
        System.out.print(", ");
     }
   }
 }
}
  1. 基数排序算法
import java.util.LinkedList;
public class Sample {
  //基数排序
  public static void main(String[] args) {
    int[] arr = {102,203,321,13,12,78,96,34,37,28,6,8,5,6};
    //1.先找到最大值 决定轮数
    int max = arr[0];
    for (int i = 0; i < arr.length; i++) {
      if (arr[i] > max) {
        max = arr[i];
     }
   }
    int radex = (max + "").length();
    //2.创建十个桶 每一个桶是LinkedList
    LinkedList<Integer>[] queues = new LinkedList[10];
    for (int i = 0; i < queues.length; i++) {
      queues[i] = new LinkedList<Integer>();
   }
    //3.进行数字分类和规整
    //r=0个位 r=1十位 r=2百位...
    for (int r = 0; r < radex; r++) {
      //先按照r进行分类
      for (int i = 0; i < arr.length; i++) {
        int index = getIndex(arr[i],r);//获取数字的r位 返回该数字要去的桶的角标0~9
        queues[index].offer(arr[i]);
     }
      //然后在重新规整到arr里
      int k = 0;
      for (int index = 0; index < queues.length; index++) {
        while(!queues[index].isEmpty()) {
          arr[k++] = queues[index].poll();
       }
     }
   }
    print(arr);
 }
  public static int getIndex(int number, int r) {
    //123 r=0
    //123 r=1
    //123 r=2
    int index = 0;
    for (int i = 0; i <= r; i++) {
      index = number % 10;
      number /= 10;
   }
    return index;
 }
  public static void print(int[] arr) {
    System.out.print("[");
    for (int i = 0; i < arr.length;i++) {
      System.out.print(arr[i]);
      if (i == arr.length - 1) {
        System.out.println("]");
     } else {
    	 System.out.print(", ");
     }
   }
 }
}
  1. 二分查找算法
public class Sample {
  //二分查找
  public static void main(String[] args) {
    int[] arr = {1,2,3,4,5,6,7,8,9};
    int min = 0;
    int max = arr.length - 1;
    int mid = (min + max) / 2;
    int key = 10;
    while (arr[mid] != key) {
      if (key < arr[mid]) {
        max = mid - 1;
     }
      if (arr[mid] < key) {
        min = mid + 1;
     }
      if (min > max) {
        mid = -1;
        break;
     }
      mid = (min + max) / 2;
   }
    System.out.println(mid);
 }
}
  1. 可变长参数列表
public class Sample {
  public static void main(String[] args) {
    show(1);
    show(1,2,3);
    show("hehe","lala","haha","xixi","heihei");
 }
  public static void show(int ... nums) {
    for (int i = 0; i < nums.length; i++) {
      System.out.print(nums[i] + " ");
   }
    System.out.println();
 }
  public static void show(String ... strs) {
    for (int i = 0; i < strs.length; i++) {
      System.out.print(strs[i] + " ");
   }
    System.out.println();
 }
}
Bubble～
关注
qdebug打印数组所有内容_4.5 案例9 使用QVector处理数组
weixin_35315373的博客
01-15 1619
本案例对应的源代码目录：src/chapter04/ks04_05。在软件研发过程中，数据结构是个无论如何也不能回避的话题。包括STL在内，很多第三方库都对常用数据结构进行了模板化封装。从本节课开始，将介绍Qt封装的几个常用数据结构模板类，本节先介绍数组类QVector。学过C++的人员都知道数组的成员在内存中是连续存放的，因此使用下标访问数组成员时效率是非常高的。但是当扩大数组容量时，有可能需要...
qdebug重定向_每个Qter都该知道的qDebug
weixin_39978350的博客
12-18 502
在项目的开发中，当我们调试程序时，最常用的就是打印信息了，Qt为我们提供了非常方便的打印信息类QDebug。大家应该已经很熟练的使用QDebug了，但也许有些地方并没有注意到，下面小豆君就介绍一下QDebug的一些常用特性。1 qDebug()的最常用法我们可以使用qDebug像使用std::cout一样，直接在重定向操作符(<如：qDebug() << "Hello" <...
vue element 实现分页功能
s1ngle的博客
09-30 2542
最近在学分页功能，这里总结下前端如何实现分页 用的是element框架和el-pagination组件 效果图: template代码： <el-pagination :page-size="pageSize" // 设置每页显示多少条 @current-change="currentChangeHandle" // 当前页数改变时调用函数 :current-page="currentPage" // 当前第几页 layout="total
C语言新手记：数位求和
Andy_corsaracing的博客
10-23 2060
题自CCF 201512-1《数位求和》 问题描述 　　给定一个十进制整数n，输出n的各位数字之和。 输入格式 　　输入一个整数n。 输出格式 　　输出一个整数，表示答案。 样例输入 20151220 样例输出 13 样例说明 　　20151220的各位数字之和为2+0+1+5+1+2+2+0=13。 评测用例规模与约定 　　所有评测用例满足：0 ≤ n ≤ 1000000000。 ————————分割线—————————————————————————— 这题简单，却一开始误入歧途，想用atoi（）去实现
python3 数组(列表)初始化
jingzhunhuoke9的博客
11-27 703
python3 数组(列表)初始化 1. 初始化一个定长的数组 有时需要预定义一个定长的数组，并给每个元素赋值 方法1： python3中代码如下： 1 2 3 4 #coding=utf-8 item='PythonTab' array=[itemforvinrange(10)]#把item的值赋给range()迭代器的每个元素 print(array) 结果： 1 ...
Java学习笔记，数组初步
02-06
"Java数组初步" 数组是Java编程语言中的一种基本数据结构，它是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。 1. 数组概述和特点 数组的定义：数组是相同类型...
java关于数组（学习笔记）
12-21
Java中的数组是一种重要的数据结构，它允许我们存储多个同类型的元素。数组被定义为一个容器，可以一次性容纳多个数据项，这些数据项在内存中是连续存放的，这使得访问和检索元素非常高效。在Java中，数组属于引用...
Java基础学习笔记之数组详解
08-25
Java中的数组是一种特殊的对象，它能够存储同一类型的多个值。数组是Java中的基本概念，它在内存中占据连续的空间，可以看作是一组相关变量的集合。数组在Java中被视为引用数据类型，这意味着数组的引用（即地址）...
【黑马程序员 Java 笔记】数组
qq_54110690的博客
02-13 6735
目录 1、数组的定义 2、数组的初始化 1）动态初始化 2）静态初始化 3、访问 1）数组的访问 2）数组元素的访问 4、内存分配 1）栈内存 2）堆内存 5、数组操作的两个常见小问题 1）索引越界 2）空指针异常 6、数组常见操作 1）遍历 2）获取最值 1、数组的定义 1）int[] arr...
Java-笔记-数组和排序-全
04-19
Java-笔记-数组和排序-全
qDebug打印输出
最新发布
qq_44236654的博客
09-01 1376
【代码】qDebug打印输出。
【贪心算法】按要求补齐数组
weixin_43779957的博客
09-22 207
给定一个已排序的正整数数组 nums，和一个正整数 n 。从 [1, n] 区间内选取任意个数字补充到 nums 中，使得 [1, n] 区间内的任何数字都可以用 nums 中某几个数字的和来表示。请输出满足上述要求的最少需要补充的数字个数。 示例 1: 输入: nums = [1,3], n = 6 输出: 1 解释: 根据 nums 里现有的组合 [1], [3], [1,3]，可以得出 1, 3, 4。 现在如果我们将 2 添加到 nums 中， 组合变为: [1], [2], [3], [1,3.
按要求补齐数组
KobeSacre的博客
12-29 233
按要求补齐数组 题目： 给定一个已排序的正整数数组 nums，和一个正整数 n 。从 [1, n] 区间内选取任意个数字补充到 nums 中，使得 [1, n] 区间内的任何数字都可以用 nums 中某几个数字的和来表示。请输出满足上述要求的最少需要补充的数字个数。 示例 1: 输入: nums = [1,3], n = 6 输出: 1 解释: 根据 nums 里现有的组合 [1], [3], [1,3]，可以得出 1, 3, 4。 现在如果我们将 2 添加到 nums 中， 组合变为: [1], [2],
【LeetCode】268 Missing Number （java实现）
添经地翼的博客
08-29 1698
Given an array containing n distinct numbers taken from 0, 1, 2, ..., n, find the one that is missing from the array. For example, Given nums = [0, 1, 3] return 2. Note: Your algorithm should run
JAVA程序设计：按要求补齐数组（LeetCode：330）
信仰.的博客
10-16 507
给定一个已排序的正整数数组 nums，和一个正整数n 。从[1, n]区间内选取任意个数字补充到nums中，使得[1, n]区间内的任何数字都可以用nums中某几个数字的和来表示。请输出满足上述要求的最少需要补充的数字个数。 示例1: 输入: nums = [1,3], n = 6 输出: 1 解释: 根据 nums里现有的组合[1], [3], [1,3]，可以得出...
C语言的学习之路-----数组
听说你很会玩的博客
12-17 1488
数组 1.1一维数组的定义和引用 1.1.1一维数组的定义方式 在C语言中使用数组必须先进行定义。 一维数组的定义方式为： 类型说明符 数组名 [常量表达式]； 其中： 类型说明符是任一种基本数据类型或构造数据类型。 数组名是用户定义的数组标识符。 方括号中的常量表达式表示数据元素的个数，也称为数组的长度。 例如： int a[10];说明整型数组a，有10个元素。 float b[10],c[20];说明实型数组b，有10个元素，实型数组c,有20个元素。
leetcode-268
一只吃猫的鱼的博客
07-17 241
Missing Number 题目 Given an array containing n distinct numbers taken from 0, 1, 2, ..., n, find the one that is missing from the array. For example, Given nums = [0, 1, 3] return 2. Note: Yo
Leetcode 268
jhlovetll的博客
12-26 176
给定一个包含 0, 1, 2, ..., n 中 n 个数的序列，找出 0 .. n 中没有出现在序列中的那个数。 示例 1: 输入: [3,0,1] 输出: 2 示例 2: 输入: [9,6,4,2,3,5,7,0,1] 输出: 8 说明: 你的算法应具有线性时间复杂度。你能否仅使用额外常数空间来实现? 方法一： 直接生成对应的列表，转为集合做差 class Solut...
python——初始化数组
热门推荐
watermelon12138的博客
12-30 4万+
因为画图中x轴与y轴的数据通常为数组格式的数据，所以先总结一下如何初始化数组： (1)list得到数组 # 通过array函数传递list对象 L = [1, 2, 3, 4, 5, 6] a = np.array(L) # 若传递的是多层嵌套的list，将创建多维数组 b = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, ...
Java入门笔记：数组详解与内存理解
Java笔记渗透是针对基础学习者的教程，主要讲解了数组在Java编程中的基本概念和使用方法。首先，我们来看第三章——数组的遍历与定义。 1. 定义数组： Java提供了三种方式来定义数组： - 第一种是动态创建，使用`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值