【原】Java学习笔记010 - 数组
package cn.temptation;
public class Sample01 {
public static void main(String[] args) {
// 需求：一堆分数，要统计最高分、最低分、总分、平均分
// int score1 = 80;
// int score2 = 70;
// int score3 = 90;
// int score4 = 65;
// // ...
// // 以计算平均分为例
// double average = ((double)(score1 + score2 + score3 + score4)) / 4;
// System.out.println("平均分为：" + average);
// 问题：相同意义的变量定义了一大堆，觉得这样一点都不简洁
// 思考解决方案：运用抽象的思维，类比生活中使用的冰格，作为一个制作冰块的容器，其内部每一个格子中的冰块可以单独使用的，兼具了批量性 和 独立性
// 那么考虑制作一个存放分数的容器，且在这个分数容器中的每一个分数也可以单独使用
// 数组：Array，存储同一数据类型的多个元素的容器
// 注意：【数组是引用数据类型（引用类型），基本数据类型是值类型】
// 内存：根据处理的内容的不同，分为 堆栈（栈：stack） 和 堆（Heap）
// 值类型：存储在栈中
// 引用数据类型：声明存储在栈中，内容存储在堆中
// 数组的格式：
// 形式1：数据类型[] 数组名（硬性要求：大家使用这种形式）：声明了一个xxx数据类型的数组，名字叫yyy
// 形式2：数据类型 数组名[]：声明了一个xxx数据类型，名字叫yyy的数组
// 声明一个成绩数组
// int[] scoreArr;
// int scoreArr[]; // 语法OK，但是不建议这样写
// 数组变量使用前必须进行初始化操作
// 语法错误：The local variable scoreArr may not have been initialized
// System.out.println(scoreArr);
// 数组初始化形式：
// 1、动态初始化：由使用者设置数组的长度，再填充元素
// 2、静态初始化：由使用者填充元素，由JDK计算数组的长度
// 动态初始化的格式：new 数据类型[数组的长度];
// A：new 关键字用来在内存的堆（Heap）中开辟一块空间
// B：数组的长度由使用者设置
// C：数组的下标（索引）用来表示数组中元素的位置，下标（索引）从0开始，到数组的长度-1结束
// 对于已经声明过的数组变量，进行动态初始化并赋值
// scoreArr = new int[3];
// 数组的初始化：可以把数组的声明 和 初始化 放在一行语句中执行
int[] scoreArr = new int[3];
// 下句输出 [I@15db9742 ，表示了scoreArr数组变量在内存中的类型 和 地址（以@符号作为分隔，前面是类型，后面是地址）
System.out.println(scoreArr); // [I@15db9742
}
}
package cn.temptation;
public class Sample02 {
public static void main(String[] args) {
// 数组的下标（索引）是从0开始的
// 数组的长度就是描述数组中元素的个数
// int[] arr = new int[3];
// arr[0] = 90; // 对数组中的第一个元素赋值为90
// 创建int类型的数组，向其中存放其他数据类型的元素，会发生什么现象？
// 向int类型的元素存放boolean类型的内容，语法出错
// 产生语法错误：Type mismatch: cannot convert from boolean to int
// arr[1] = true; // 对数组中的第二个元素赋值为true
// 向int类型的元素存放long类型的内容，语法出错
// 产生语法错误：Type mismatch: cannot convert from long to int
// arr[1] = 12345678901L;
// 向int类型的元素存放byte类型的内容，语法OK
// arr[1] = (byte)126;
// 向int类型的元素存放short类型的内容，语法OK
// arr[1] = (short)130;
// 【数组在内存中的存储形式】
// 赋值号左边的是数组的声明，类比名片
// 赋值号右边的是数组的内容，类比具体的家的位置
// 通过名片找到具体的家的位置
// 通过栈上声明的变量找到堆中具体存放内容的位置来使用数组
// System.out.println(arr); // [I@15db9742
// 数组中元素的默认值
// byte、short、int、long类型的数组的元素默认值为0
// int[] arr1 = new int[3];
// System.out.println(arr1[0]); // 0
// System.out.println(arr1[1]); // 0
// System.out.println(arr1[2]); // 0
// byte[] arr2 = new byte[3];
// System.out.println(arr2[0]); // 0
// System.out.println(arr2[1]); // 0
// System.out.println(arr2[2]); // 0
//
// short[] arr3 = new short[3];
// System.out.println(arr3[0]); // 0
// System.out.println(arr3[1]); // 0
// System.out.println(arr3[2]); // 0
//
// long[] arr4 = new long[3];
// System.out.println(arr4[0]); // 0
// System.out.println(arr4[1]); // 0
// System.out.println(arr4[2]); // 0
// double、float类型的数组的元素默认值为0.0
// double[] arr5 = new double[3];
// System.out.println(arr5[0]); // 0.0
// System.out.println(arr5[1]); // 0.0
// System.out.println(arr5[2]); // 0.0
//
// float[] arr6 = new float[3];
// System.out.println(arr6[0]); // 0.0
// System.out.println(arr6[1]); // 0.0
// System.out.println(arr6[2]); // 0.0
// char类型的数组的元素默认值为'\u0000'
// char[] arr7 = new char[3];
// System.out.println(arr7[0]); // '\u0000'
// System.out.println(arr7[1]); // '\u0000'
// System.out.println(arr7[2]); // '\u0000'
// boolean类型的数组的元素默认值为false
boolean[] arr8 = new boolean[3];
System.out.println(arr8[0]); // false
System.out.println(arr8[1]); // false
System.out.println(arr8[2]); // false
}
}
package cn.temptation;
public class Sample03 {
public static void main(String[] args) {
int[] scoreArr = new int[3];
System.out.println(scoreArr); // [I@15db9742
System.out.println(scoreArr[0]); //
System.out.println(scoreArr[1]); //
System.out.println(scoreArr[2]); //
System.out.println("-------------------------------------");
// 对数组中的部分元素进行赋值
scoreArr[0] = 80;
scoreArr[2] = 55;
// 1、数组的元素的值发生变化后，数组的地址没有变化
// 2、数组的元素的值发生变化后，数组中没有发生变化的元素的值还是之前的值
System.out.println(scoreArr); // [I@15db9742
System.out.println(scoreArr[0]); //
System.out.println(scoreArr[1]); //
System.out.println(scoreArr[2]); //
}
}
package cn.temptation;
public class Sample04 {
public static void main(String[] args) {
// 需求：把数组中的元素的值都显示出来
int[] scoreArr = new int[3];
// 下面的写法可以实现需求，但是使用起来很不方便
// System.out.println(scoreArr[0]);
// System.out.println(scoreArr[1]);
// System.out.println(scoreArr[2]);
// 看到有重复的操作，就想到了循环
// for (int i = 0; i < 3; i++) {
// System.out.println(scoreArr[i]);
// }
// 上面的写法不具备通用性，因为这里的数字3是硬编码，其实它应该表示为数组的长度（数组中元素的个数）
// 通过使用 数组名.length 可以获取到数组的长度
// System.out.println("数组的长度为：" + scoreArr.length);
// 下面的写法就具备通用性（注意：eclipse中提供的for语句块结构：iterate over array，即在数组上进行迭代）
// for (int i = 0; i < scoreArr.length; i++) {
// System.out.println(scoreArr[i]);
// }
// 还有更加简单的写法，使用增强型for循环-----> foreach
// 增强型for循环的格式：for(数据类型 遍历变量名(迭代变量名) : 被遍历变量名(被迭代变量名)) { ... }
// for (int i : scoreArr) {
// System.out.println(i);
// }
// 注意：遍历变量名(迭代变量名)可以由使用者自己定义名称
// for (int item : scoreArr) {
// System.out.println(item);
// }
// 产生错误：Type mismatch: cannot convert from element type int to byte
// for (byte i : scoreArr) {
// System.out.println(i);
// }
// 产生错误：Type mismatch: cannot convert from element type int to short
// for (short i : scoreArr) {
// System.out.println(i);
// }
// 语法OK
// for (long i : scoreArr) {
// System.out.println(i);
// }
// 总结：被遍历的变量名的数据类型，认为其内部的元素也是该数据类型的，那么用范围比它大的数据类型接收时是可以的
// 用范围比它小的数据类型接收时就会抱语法错误
// 需求：使用循环和数组长度等技术点，制作一个方法printArray，用来打印数组中的元素，要求显示为[元素1的值, 元素2的值, ... 元素n的值]
printArray(scoreArr);
}
/**
* 打印数组方法
* @param arr：int类型的数组
*/
public static void printArray(int[] arr) {
// 最左边先打印出一个"["
System.out.print("[");
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) { // 数组中的最后一个元素，加上"]"
System.out.print(arr[i] + "]");
} else { // 数组中的其他元素，加上","
System.out.print(arr[i] + ",");
}
}
// 换行
System.out.println();
}
}
package cn.temptation;
public class Sample05 {
public static void main(String[] args) {
int[] arr = new int[3];
arr[0] = 10;
arr[1] = 21;
arr[2] = 30;
// 需求：制作一个方法getMaxItem，获取数组中的最大元素值
int maxItem = getMaxItem(arr);
System.out.println("数组中最大的元素为：" + maxItem);
// 需求：制作一个方法getMinItem，获取数组中的最小元素值
int minItem = getMinItem(arr);
System.out.println("数组中最小的元素为：" + minItem);
// 需求：制作一个方法getTotal，获取数组中的元素的总和
int total = getTotal(arr);
System.out.println("数组中元素的总和为：" + total);
// 需求：制作一个方法getAverage，获取数组中的元素的平均值
double average = getAverage(arr);
System.out.println("数组中元素的平均值为：" + average);
}
/**
* 获取数组中的最大元素值
* @param arr：数组
* @return：最大的元素值
*
* 思路：使用穷举思路
* 1、先设置一个作为比较的标杆，从数组中拿出一个元素认为它是最大的
* 2、把数组中的其他元素与之进行比较
* 3、如果有其他的元素比作为标杆的元素大，则替换之
* 4、比较完成后，就可以得到数组中的最大元素
*/
public static int getMaxItem(int[] arr) {
int tempMax = arr[0];
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if (arr[i] > tempMax) {
tempMax = arr[i];
}
}
return tempMax;
}
/**
* 获取数组中的最小元素值
* @param arr：数组
* @return：最小的元素值
*/
public static int getMinItem(int[] arr) {
int tempMin = arr[0];
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if (arr[i] < tempMin) {
tempMin = arr[i];
}
}
return tempMin;
}
/**
* 获取数组中的元素值的总和
* @param arr：数组
* @return：数组中元素的总和
*/
public static int getTotal(int[] arr) {
int total = 0;
// 遍历数组
for (int i = 0; i < arr.length; i++) {
total += arr[i];
}
return total;
}
/**
* 获取数组中的元素值的平均值
* @param arr：数组
* @return：数组中元素的平均值
*/
public static double getAverage(int[] arr) {
double total = 0.0;
for (int i = 0; i < arr.length; i++) {
total += arr[i];
}
return total / arr.length;
}
}
package cn.temptation;
public class Sample06 {
public static void main(String[] args) {
int[] arr1 = new int[3];
arr1[0] = 80;
arr1[2] = 55;
int[] arr2 = new int[3];
arr2[0] = 80;
arr2[2] = 55;
System.out.println("数组1的地址：" + arr1); // [I@15db9742
printArray(arr1);
System.out.println("数组2的地址：" + arr2); // [I@6d06d69c
printArray(arr2);
System.out.println("----- 修改元素值 -----");
arr2[0] = 38;
arr2[1] = 100;
System.out.println("数组1的地址：" + arr1); // [I@15db9742
printArray(arr1);
System.out.println("数组2的地址：" + arr2); // [I@6d06d69c
printArray(arr2);
// 不同的数组，元素的值相同，修改后，对其他数组中的元素的值无影响
// 因为不同的数组中的元素存放在内存的堆中不同的空间里
// 从运行的结果得知：
// 【只要使用了new关键字，就在内存的堆中开辟了新的空间】
}
/**
* 打印数组方法
* @param arr：int类型的数组
*/
public static void printArray(int[] arr) {
// 最左边先打印出一个"["
System.out.print("[");
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) { // 数组中的最后一个元素，加上"]"
System.out.print(arr[i] + "]");
} else { // 数组中的其他元素，加上","
System.out.print(arr[i] + ",");
}
}
// 换行
System.out.println();
}
}
package cn.temptation;
public class Sample07 {
public static void main(String[] args) {
int[] arr1 = new int[3];
arr1[0] = 80;
arr1[2] = 55;
// 注意：下句语句体现了引用数据类型的特点
int[] arr2 = arr1;
System.out.println("数组1的地址：" + arr1); // [I@15db9742
printArray(arr1);
System.out.println("数组2的地址：" + arr2); // [I@15db9742
printArray(arr2);
System.out.println("----- 修改元素值 -----");
arr2[0] = 38;
arr2[1] = 100;
System.out.println("数组1的地址：" + arr1); // [I@15db9742
printArray(arr1);
System.out.println("数组2的地址：" + arr2); // [I@15db9742
printArray(arr2);
// 从运行的结果得知：
// 1、只要使用了new关键字，就在内存的堆中开辟了新的空间
// 2、引用数据类型在做值传递时，传递的是引用
}
/**
* 打印数组方法
* @param arr：int类型的数组
*/
public static void printArray(int[] arr) {
// 最左边先打印出一个"["
System.out.print("[");
// 遍历数组
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) { // 数组中的最后一个元素，加上"]"
System.out.print(arr[i] + "]");
} else { // 数组中的其他元素，加上","
System.out.print(arr[i] + ",");
}
}
// 换行
System.out.println();
}
}
package cn.temptation;
public class Sample08 {
public static void main(String[] args) {
// 值类型的特点
// int i = 2;
// int j = 2;
//
// System.out.println("i的值为：" + i);
// System.out.println("j的值为：" + j);
//
// System.out.println("----- 修改元素值 -----");
//
// j = 3;
//
// System.out.println("i的值为：" + i);
// System.out.println("j的值为：" + j);
int i = 2;
int j = i;
System.out.println("i的值为：" + i);
System.out.println("j的值为：" + j);
System.out.println("----- 修改元素值 -----");
j = 3;
System.out.println("i的值为：" + i);
System.out.println("j的值为：" + j);
// 值类型的特点
// 存储在栈上，没有栈和堆之间的指向引用，变化只影响自身
}
}
package cn.temptation;
public class Sample09 {
public static void main(String[] args) {
// 数组初始化
// 静态初始化：由使用者填充数组的元素，由JDK自动判定数组的长度
// 静态初始化的格式：
// 1、简写形式：{ 元素1, 元素2, ... 元素n}
// 2、完整形式：new 数据类型[] { 元素1, 元素2, ... 元素n}
// 简写形式
int[] arr1 = { 10, 20, 30 };
System.out.println("数组的长度为：" + arr1.length);
// 完整形式
int[] arr2 = new int[] { 10, 20, 30 };
System.out.println("数组的长度为：" + arr2.length);
// 遍历数组中的元素
// 方式1：一般for循环
for (int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i]);
}
// 方式2：增强型for循环
for (int item : arr2) {
System.out.println(item);
}
// 注意：
// 1、静态初始化的简写形式看起来没有new，但是实际上还是做了new的操作，还是在内存的堆上开辟了空间
// 2、数组的初始化有两种形式，使用时只能选择一种形式使用，不能混搭
// 混搭动态初始化和静态初始化会产生语法错误
// 产生语法错误：Cannot define dimension expressions when an array initializer is provided
// int[] arr3 = new int[3] { 10, 20, 30 };
}
}
package cn.temptation;
public class Sample10 {
public static void main(String[] args) {
// 1、下面语句是否在内存的堆中开辟了空间？ 答：new出了空间，地址为15db9742
// 2、下面这个数组长度是多少？ 答：数组长度为0
// 3、如何为这个数组填充元素并给元素赋值？
int[] arr = {};
System.out.println(arr); // [I@15db9742
System.out.println("数组的长度为：" + arr.length); // 0
// 遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
for (int item : arr) {
System.out.println(item);
}
// 下句执行时会产生异常：java.lang.ArrayIndexOutOfBoundsException: 0，数组索引越界异常
// 因为当前arr数组中一个元素都没有，而下句语句要给第一个元素进行赋值，自然出现数组索引越界异常
// arr[0] = 10;
// 下句执行时会产生异常：java.lang.ArrayIndexOutOfBoundsException: 10，数组索引越界异常
// arr[10] = 99;
// 由上面的语句得知java.lang.ArrayIndexOutOfBoundsException后的数字指的是越界元素对应的索引
// 考虑1、考虑设置数组arr的length属性
// 语法错误：The final field array.length cannot be assigned
// 数组的length属性可以被读取，但是不可以被修改
// arr.length = 3;
// 考虑2、张冠李戴
// 通过创建一个新的数组，在堆中开辟一块新的空间，然后把指向之前开辟出的空间的引用（arr的栈堆之间的引用）改为指向新开辟的空间的引用
int[] arrExtend = { 10, 20, 30 };
arr = arrExtend;
// 遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
for (int item : arr) {
System.out.println(item);
}
}
}
【原】Java学习笔记010 - 数组的更多相关文章
- 【原】Java学习笔记012 - 数组
package cn.temptation; public class Sample01 { public static void main(String[] args) { // 需求:小店对自己的 ...
- 【原】Java学习笔记011 - 数组
package cn.temptation; import java.util.Scanner; public class Sample01 { public static void main(Str ...
- Java学习笔记七——数组工具类Arrays
数组工具类Arrays Java提供的Arrays类里包含的一些static修饰的方法可以直接操作数组.若将里面的方法用熟的话,那开发效率会大大提高.下面介绍其中的方法. List<T> ...
- java学习笔记六——数组
数组类型 数组是一种常见的数据结构,可用于存放多个数据,每一个数组元素存放一个数据,通常可以通过下标进行访问其元素. Java数组要求所有数组元素具有相同的数据类型.因此,数组元素的数据类型是唯一的. ...
- Java学习笔记day04_数组
1.switch case switch语句中表达式的数据类型是有要求的: JDK 1.0 ~ 1.4 , 数据类型接受byte, short, int, char JDK 1.5 , 数据类型接受b ...
- 1.14（java学习笔记）数组
假如我们需要用到1000个相同类型的数据,肯定不可能创建1000个变量, 这样既不方便,也不直观,也不便于我们使用.这时就需要用到数组. 一.数组的声明与使用 public class Array { ...
- Java学习笔记 03 数组
一.数组的创建和使用 数组的创建和使用 >>创建方法1:先声明,再用new关键字分配内存(使用new关键字分配内存,整形数组中各个元素的初始值都为0) String str[]; str= ...
- Java学习笔记之——数组
一.一维数组 1. 什么是数组 变量:在内存中开辟了一块空间 数组:在内存中开辟了一块连续的空间,每块空间保存的值/对象叫做元素,每个元素都有对应的下标.(下标从0开始) 2. 初始化一个数组 1)不 ...
- java学习笔记之数组
随机推荐
- mysql+postgresql备份与恢复
mysql备份一个库, mysqldump -u用户名 -p密码 [选项] [数据库名] > /备份路径/备份文件名 mysqldump -uuser -p123123 auth > / ...
- Docker基础命令和时区问题
Docker 命令 1. 安装Docker # ubuntu系统安装 $ sudo apt install docker-ce # 启动docker $ sudo systemctl start do ...
- 心路历程（一）-自学java两个月心得
这是我的第一条博文,在敲这些文字的时候我已经是一名大四的"老者".说自己"老者"确实如此,因为以前每当这个时候大一新学妹有上架了,哈哈,每当这个时候我们就想了很 ...
- Hive篇--搭建Hive集群
一.前述 Hive中搭建分为三中方式 a)内嵌Derby方式 b)Local方式 c)Remote方式 三种方式归根到底就是元数据的存储位置不一样. 二.具体实现 a)内嵌Derby方式 使用derb ...
- 9.Django form组件
Form组件 Django的Form主要具有一下几大功能: 生成HTML标签 验证用户数据(显示错误信息) HTML Form提交保留上次提交数据 初始化页面显示内容 创建Form类时,主要涉及到 [ ...
- CORS（跨域）请求总结和测试
一.简单请求与非简单请求 跨域请求分为简单与非简单请求,同时满足以下两种条件的可以确定为简单请求. 简单请求的请求方法 请求方法 说明 head 发送头部信息 get post 简单请求的HT ...
- Linux系统打开文件最大数量限制（进程打开的最大文件句柄数设置）
ulimit [-HSTabcdefilmnpqrstuvx [limit]] 利用ulimit命令可以对资源的可用性进行控制. -H选项和-S选项分别表示对给定资源的硬限制(hard limit ...
- 将Maple输出的LaTex导出到txt文件
将Maple输出的LaTex导出到txt文件 1. 生成LATEX Maple可以把它的表达式转换成LATEX, 使用latex命令即可: > latex(x^2+y^2=z^2); {x}^{ ...
- 手把手教你如何优雅的使用Aop记录带参数的复杂Web接口日志
前言 不久前,因为需求的原因,需要实现一个操作日志.几乎每一个接口被调用后,都要记录一条跟这个参数挂钩的特定的日志到数据库.举个例子,就比如禁言操作,日志中需要记录因为什么禁言,被禁言的人的id和各种 ...
- 如何合理封装你的轮子、飞机、大炮（以封装OkHttp为例）
前言 对于程序员来说,很多时候,我们都在造房子,从学会框架或者是学会构建整个项目之后,慢慢的我们就会觉得自己在做的事情是一种重复劳动,很多时候只不过是换个面孔而已.而更快的造房子,造好看的房子可能是进 ...