JAVA基础6——数组
一维数组
一维数组的概述和格式
数组的定义：
数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器
数组既可以存储基本数据类型，也可以存储引用数据类型。
数组的格式
- 数据类型 [] 数组名；
- 数据类型 数组名 []；
举例
int [] a；定义一个int类型的数组a变量（推荐）int a []；定义一个int类型的a数组变量
注意：效果可以认为是一样的，都是定义一个int数组，但是念法上有些小区别。推荐使用第一种。
一维数组的初始化
数组初始化概述：
Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
数组的初始化方式
- 动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
- 静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度
动态初始化：
格式：数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
举例：int[] arr = new int[3];
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。
左边：
int 表示数组中元素的数据类型
[] 表示数组
arr 数组的名字
简单说：定义了一个int类型的数组，名称是arr。
右边：
new：class是用来定义一个类的，new是用来创建一个 实体 的。(为数组分配内存空间)
int 表示数组中元素的数据类型
[] 表示数组
3 表示数组长度，数组中元素的个数
简单说：创建一个int类型的数组 实体，该 实体 中可以存储5个int类型的元素。
如便获取数组的元紊呢?
通过：
数组名 [索引]
静态初始化：
格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例：int[] arr = new int[]{1,2,3};
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。
其实这种写法还有一个简化的写法
简化：int[] arr = {1,2,3};
当明确数组元素时，建议使用静态初始化比较方便
注意：
- 定义数组时，不要忘记指定数组的长度和名称；
- [ ]可以放在数组名的左边，也可以放在右边。
- 在指定了数组长度的同时，不可列出其元素内容，因为可能出现元素类型与数组定义类型不一致。（不要动态静态同时使用）
int[] arr=new int[3]{1,2,3}
JAVA的内存分配
Java程序为了提高程的效率，就对数据进行了不同空间的分配。
具体的是划分为了如下5个内存空间：
栈：局部变量
堆：new出来的东西
方法区：（面向对象部分详细讲解）
本地方法区：（和系统相关）
寄存器：（CPU使用）
public class DemoArray {
public static void main(String[] args){
int arr[]=new int[5];
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[4]);
}
}
输出结果
[I@3429dbb8
0
0
0
[I@3429dbb8的解释：
[ 表示这是个数组(一维数组)
I 表示数组的int类型
@ 连接符
3429dbb8 十六进制的数字，使用过哈希算法得到的。表示的是一个内存地址值
堆的特点：
- 堆内存的实体都有首地址值
- 堆内存的数据不在被使用时，会在jvm空闲的时候，被java垃圾回收机制自动回收
- 堆内存实体里面的变量都有默认值
| 变量 | 默认值 |
|---|---|
| byte,short,int,long | 0 |
| double,float | 0.0 |
| char | ‘\u0000’ 空字符 |
| boolean | false |
| 引用类型 | null |
栈的特点：
数据被使用完，会立马自动从内存清除。
栈内存的数据用完就释放掉
{
int a=100；
System.out.println(a);
}
图解：
class ArrayDemo4 {
public static void main(String[] args) {
//定义第一个数组
int[] arr = new int[3];
arr[0] = 88;
arr[1] = 33;
arr[2] = 66;
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println("----");
//定义第二个数组
int[] arr2 = new int[3];
arr2[0] = 22;
arr2[1] = 44;
arr2[2] = 55;
System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
System.out.println("----");
//定义第三个数组
int[] arr3 = arr;
arr3[0] = 100;
arr3[1] = 200;
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
操作数组可能遇到的问题(待补全)
- 数组角标越界异常
ArrayIndexOutOfBoundsException(程序运行的时候发生)
访问到了数组的最后一个元素后，你还在继续访问,此时就会出现此问题。 - 空指针异常
NullPointerException(程序运行的时候发生)
一个引用变量已经不再指向对内存的地址。这个时候，你还在使用这个引用。
一维数组基本操作
数组的遍历
数组遍历：就是依次输出数组中的每一个元素
注意：数组提供一个属性length，用于获取数组的长度
格式：数组名.length
public class DemoArray1 {
public static void main(String[] args){
int[] arr={5,8,4,890,2,888,67,56,8,9,8,7,6,5,45,345,3,45,435};
int[] arr1={59,8,7,6,5,4,6,5,45,345,3,45,435};
int[] arr2={59,18,447,6,5228,4,6660,5,45,75345,73,45,435};
ergodic(arr);
System.out.println("----------------------------------------------------------");
ergodic(arr1);
System.out.println("----------------------------------------------------------");
ergodic(arr2);
System.out.println("----------------------------------------------------------");
}
public static void ergodic(int[] arr){
System.out.print("["); //输出之前加上左括号[
for (int i=0;i<arr.length;i++){
if (i==arr.length-1){
System.out.println(arr[i]+"]"); //如果是最后一位元素，则输出并加上右括号]
}else {
System.out.print(arr[i]+","); //否则输出一个元素并加上逗号,
}
}
}
}
操作数组，肯定离不开角标。--------角标思想
获取最值
思路：将数组的第一个元素定义为最大值，然后依次和其他元素进行比较，如果其他元素比标记的最大值还大，就进行重新标记，最后将最大值的标记返回即可。
public class DemoArray1 {
public static void main(String[] args){
int[] arr={5,8,4,890,2,888,67,56,8,9,8,7,6,5,45,345,3,45,435};
int MAX=getMax(arr);
System.out.println("MAX="+MAX);
}
public static int getMax(int arr[]){ //求极值
int MAX=arr[0]; //从数组中任意的找一个元素作为参照物
for (int x=1;x<arr.length;x++){ //然后遍历其他的元素
if (MAX<arr[x]){ //依次获取和参照物进行比较，如果大就留下来，如果小，就离开。
MAX=arr[x]; //最后参照物里面保存的就是最大值。
}
}
return MAX;
}
}
数组 元素逆序
public class DemoArray1 {
public static void main(String[] args){
int[] arr2={59,18,447,6,5228,4,6660,5,45,75345,73,45,435};
reverseOrder(arr2);
ergodic(arr2);
System.out.println("----------------------------------------------------------");
}
public static void reverseOrder(int[] arr){ //reverseOrder逆序
for (int x=0;x<=arr.length/2;x++){
arr[x]=arr[x]+arr[(arr.length-1)-x];
arr[(arr.length-1)-x]=arr[x]-arr[(arr.length-1)-x];
arr[x]=arr[x]-arr[(arr.length-1)-x];
}
} //reverseOrder逆序
}
数组查表法
public class DemoArray1 {
public static void main(String[] args){
String[] arr3={"星期一","星期二","星期三","星期四","星期五","星期六","星期七"};
Scanner sc=new Scanner(System.in);
System.out.println("请输入一个索引0-6：");
int index=sc.nextInt();
System.out.println("对应的日期是"+arr3[index]);
}
数组元素查找
import java.util.Scanner;
public class DemoArray1 {
public static void main(String[] args){
int[] arr={5,8,4,890,2,888,67,56,8,9,8,7,6,5,45,345,3,45,435};
Scanner sc1=new Scanner(System.in);
System.out.println("请输入一个数值：");
int value=sc.nextInt();
int getIndex = getIndex(arr, value);
System.out.println("该元素的索引为" + getIndex);
public static int getIndex(int[] arr,int value){
for (int i=0;i<arr.length;i++){
if (value==arr[i]){
return i;
}
}
return -1;
}
}
数组排序和二分查找(后面在数组高级部分讲解)
二维数组
概述:二维数组其实就是一个元素为一维数组的数组
第一种格式
数据类型[][] 变量名 = new 数据类型[m][n];
例:int[][] arr = new int[3][2];
定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称分别为arr[0], arr[1], arr[2]
给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;
内存图解
第二种格式
数据类型[][] 变量名 = new 数据类型[m][];
例:int[][] arr = new int[3][];
二维数组中有3个一维数组
每个一维数组都是默认初始化值null----引用类型的初始化值为Null
可以对这个三个一维数组分别进行初始化
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];
内存图解
第三种格式
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化版格式：
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
定义一个名称为arr的二维数组
二维数组中的有三个一维数组
每一个一维数组中具体元素也都已初始化
第一个一维数组 arr[0] = {3,8,2};
第二个一维数组 arr[1] = {2,7};
第三个一维数组 arr[2] = {9,0,1,6};
第三个一维数组的长度表示方式：arr[2].length;
注意
int[] x,y[]等价于int[] x;int[] y[]
定义了一个一维数组x和一个二维数组y.
二维数组基本操作
二维数组遍历
public class DemoArray2 {
public static void main(String[] args) {
int arr[][] = {{123, 345, 23}, {4, 11, 545, 7}, {0, 234, 821, 444324, 231}};
ergodic(arr);
}
public static void ergodic(int[][] arr) {
for (int x = 0; x < arr.length; x++) { //外循环控制二维数组长度(一维数组的个数)
for (int y = 0; y < arr[x].length; y++) { //内循环控制一维数组长度
System.out.print(arr[x][y] + " ");
}
System.out.println();
}
}
}
数组元素求和
public class DemoArray2 {
public static void main(String[] args) {
int arr[][] = {{123, 345, 23}, {4, 11, 545, 7}, {0, 234, 821, 444324, 231}};
System.out.println(sum(arr));
public static int sum(int[][] arr) {
int sum = 0;
for (int x = 0; x < arr.length; x++) { //外循环控制二维数组长度(一维数组的个数)
for (int y = 0; y < arr[x].length; y++) { //内循环控制一维数组长度
sum += arr[x][y]; //累加
}
}
return sum;
}
}
打印杨辉三角
public class DemoArray2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入生成杨辉三角的行数");
int n = sc.nextInt();
yhTriangle(n);
}
public static void yhTriangle(int n) {
int[][] arr=new int[n][n];
for (int a=0;a<arr.length;a++){ //赋值每行第一列和最后一列为1
arr[a][0]=1;
arr[a][a]=1;
}
for (int a=2;a<arr.length;a++){ //赋值其他元素
for (int b=1;b<=a-1;b++){
arr[a][b]=arr[a-1][b-1]+arr[a-1][b];
}
}
for (int a=0;a<arr.length;a++){ //打印杨辉三角
for (int b=0;b<=a;b++){
System.out.print(arr[a][b]+" ");
}
System.out.println();
}
}
}
注意事项
Java中的参数传递问题：
基本类型：形式参数的改变对实际参数没有影响。
引用类型：形式参数的改变直接影响实际参数。
public class Text1 {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("第一次赋值:" + "a:" + a + ",b:" + b); //a:10,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]); //??? 4
}
public static void change(int a, int b) { //a=10,b=20
System.out.println("传递的参数值" + "a:" + a + ",b:" + b); //a:10,b:20
a = b; //a=20
b = a + b; //b=40
System.out.println("方法体里的值:" + "a:" + a + ",b:" + b); //a:20,b:40
}
public static void change(int[] arr) { //arr={1,2,3,4,5};
for (int x = 0; x < arr.length; x++) {
if (arr[x] % 2 == 0) {
arr[x] *= 2;
}
}
//arr={1,4,3,8,5};
}
}
输出结果
第一次赋值:a:10,b:20
传递的参数值a:10,b:20
方法体里的值:a:20,b:40
调用完方法后的值a:10,b:20
4
图解:
练习:
需求:公司采用公用电话传递数据信息，数据是小于8位的整数，为了确保安全，在传递过程中需要加密，加密规则如下：
首先将数据倒序，然后将每位数字都加上5，再用和除以10的余数代替该数字，
最后将第一位和最后一位数字交换。 请任意给定一个小于8位的整数，
然后，把加密后的结果在控制台打印出来。
题目要求：
A:数据是小于8位的整数
定义一个int类型的数据
int number = 123456;
B:加密规则
a:首先将数据倒序
结果 654321
b:然后将每位数字都加上5，再用和除以10的余数代替该数字
结果 109876
c:最后将第一位和最后一位数字交换
结果 609871
C:把加密后的结果输出在控制台
涉及知识点：变量 数据类型 运算符 键盘录入 语句 方法 数组
import java.util.Scanner;
public class Text2 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入需要加密的数字(小于八位数):");
int number=sc.nextInt();
System.out.print("加密后的结果为:");
encryption(number);
}
public static void encryption(int number){
int[] arr=new int[8];
int index=0;
while (number>0){
arr[index]=number%10;
index++;
number/=10;
}
for (int x=0;x<index;x++){
arr[x]+=5;
arr[x]%=10;
}
arr[0]=arr[0]+arr[index-1];
arr[index-1]=arr[0]-arr[index-1];
arr[0]=arr[0]-arr[index-1];
for (int x=0;x<index;x++) {
System.out.print(arr[x]);
}
}
}
1890
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
