【原】Java学习笔记011 - 数组
package cn.temptation;
import java.util.Scanner;
public class Sample01 {
public static void main(String[] args) {
// 需求：定义一个数组存储星期一、星期二、...星期日，打印该数组形式为[星期一, 星期二, ...星期日]，根据用户输入的数字（1~7），显示是星期几？
// 写法一、考虑使用字符串类型的数组
// // 1、创建一个数组来存储星期一、星期二、...星期日
// String[] weekDayArr = { "星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"};
// printArray(weekDayArr);
//
// // 2、接收键盘录入
// System.out.println("输入一个数字就可以找到对应是星期几：");
// Scanner input = new Scanner(System.in);
// int weekDay = input.nextInt();
// input.close();
//
// // 3、判断输入的数字和数组中某个元素的索引之间的关系
// if (weekDay >= 1 && weekDay <= 7) {
// System.out.println("选择的是：" + weekDayArr[weekDay - 1]);
// } else {
// System.out.println("输入的数字不在范围内！");
// }
// 写法二、考虑使用int类型的数组
// 1、创建一个数组来存储星期一、星期二、...星期日
int[] weekDayArr = { 1, 2, 3, 4, 5, 6, 7 };
printArray(weekDayArr);
// 2、接收键盘录入
System.out.println("输入一个数字就可以找到对应是星期几：");
Scanner input = new Scanner(System.in);
int weekDay = input.nextInt();
input.close();
// 3、判断输入的数字和数组中某个元素的索引之间的关系
if (weekDay >= 1 && weekDay <= 7) {
System.out.println("选择的是：" + convertNumberToString(weekDayArr[weekDay - 1]));
} else {
System.out.println("输入的数字不在范围内！");
}
}
/**
* 打印数组
* @param arr：字符串数组
*/
public static void printArray(String[] 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();
}
/**
* 打印数组（重载方法）
* @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();
}
/**
* 数字转换为星期字符串的方法
* @param i：数字
* @return：星期字符串
*/
public static String convertNumberToString(int i) {
String result = "";
switch (i) {
case 1:
result = "星期一";
break;
case 2:
result = "星期二";
break;
case 3:
result = "星期三";
break;
case 4:
result = "星期四";
break;
case 5:
result = "星期五";
break;
case 6:
result = "星期六";
break;
case 7:
result = "星期日";
break;
default:
result = "输入错误！";
break;
}
return result;
}
}
package cn.temptation;
public class Sample02 {
public static void main(String[] args) {
// 需求：给定一个int类型的数组，实现如下功能：将数组反转，比如：{1, 2, 3} -----> {3, 2, 1}, {1, 2, 3, 4} -----> {4, 3, 2, 1}
// 思路：
// 1、可能有两种情况，一种数组的长度为奇数，一种数组的长度为偶数
// 2、如果长度为奇数，中间那个元素不动，第一个元素和最后一个元素对调，第二个元素和倒数第二个元素对调，...，
// 中间那个元素的前一个元素和中间那个元素的后一个元素对调
// 3、如果长度为偶数，第一个元素和最后一个元素对调，第二个元素和倒数第二个元素对调，...，
// 中间位置的前一个元素和中间位置的后一个元素对调
int[] arr1 = { 1, 2, 3 };
System.out.println("反转前的数组：");
printArray(arr1);
// 调用方法
// reversalArray1(arr1);
reversalArray2(arr1);
System.out.println("反转后的数组：");
printArray(arr1);
System.out.println("------------------------------");
int[] arr2 = { 1, 2, 3, 4 };
System.out.println("反转前的数组：");
printArray(arr2);
// reversalArray2(arr2);
reversalArray1(arr2);
System.out.println("反转后的数组：");
printArray(arr2);
// 注意：
// 1、代码写完后，自己再考虑一下，不要抱着糊完任务的心态
// 2、思考问题的时候是区分了数组为奇数长度和偶数长度的，在编写代码时，发现对于奇数长度，因为其中间元素不参与反转，相当于反转时把中间元素拿掉
// 即其操作次数：(数组长度 - 1) / 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();
}
/**
* 奇数长度的数组反转（因为后续的显示操作也是使用堆内存中的内容，所以该方法使用void：无返回即可）
* @param arr
*/
public static void reversalArray1(int[] arr) {
// 下面写法逻辑错误，这样会对调两次，等于没有对调
// for (int i = 0, j = arr.length - 1; i < arr.length; i++, j--) {
for (int i = 0, j = arr.length - 1; i < arr.length / 2; i++, j--) {
// 对调：第一个元素和最后一个元素对调，第二个元素和倒数第二个元素对调，...，
// 中间那个元素的前一个元素和中间那个元素的后一个元素对调
// 定义临时变量接收
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
/**
* 偶数长度的数组反转（因为后续的显示操作也是使用堆内存中的内容，所以该方法使用void：无返回即可）
* @param arr
*/
public static void reversalArray2(int[] arr) {
for (int i = 0; i < arr.length / 2; i++) {
// 对调：第一个元素和最后一个元素对调，第二个元素和倒数第二个元素对调，...，
// 中间位置的前一个元素和中间位置的后一个元素对调
// 定义临时变量接收
int temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
}
}
}
package cn.temptation;
public class Sample03 {
public static void main(String[] args) {
int[] arr = { 10, 20, 30 };
System.out.println(arr); // [I@15db9742
System.out.println(arr[0]); //
arr = null;
// 产生异常：java.lang.NullPointerException 空指针异常
// 有警告：Null pointer access: The variable arr can only be null at this location
// System.out.println(arr[0]);
// 产生异常：java.lang.NullPointerException 空指针异常
// 有警告：Null pointer access: The variable arr can only be null at this location
// System.out.println(arr.length);
// 下句语句执行时无异常
System.out.println(arr); // null
// 注意：
// 1、设置引用类型变量的值为null，其实就是让其栈中声明的引用类型变量 与 在堆中开辟的空间之间的联系断开
// 2、堆中原来开辟的空间并不会立即消失
// null是一个特殊值，类比boolean类型的特殊值true 和 false
// null表示的是引用数据类型的空值，引用数据类型的默认值是null
// 如下两种写法意义相同
// int[] arrExtend;
// int[] arrExtend = null;
// null不能用于给基本数据类型（值类型）赋值，null只能用于引用数据类型
// 语法错误：Type mismatch: cannot convert from null to int
// int i = null;
}
}
package cn.temptation;
public class Sample04 {
public static void main(String[] args) {
// int[] arr = { 1, 2, 3 };
// printArray(arr);
// 匿名数组：没有显示定义数组名的数组
// 这里匿名数组使用new关键字直接在内存的堆中开辟元素个数长度的空间，并存储这些元素，然后作为实参传递给方法的形参供方法使用
// printArray(new int[] { 1, 2, 3 });
// 匿名数组的优点：直接new出来使用，不用再做声明
// 匿名数组的缺点：只能使用一次（因为没有声明数组变量，一次使用完毕后就找不到了）
// 注意：匿名数组定义时，不能使用静态初始化的简写形式，语法出错
// 语法错误：Syntax error on token "printArray", @ expected before this token
// printArray({ 4, 5, 6 });
// 注意：匿名数组定义时，可以使用动态初始化的形式，但是这样定义后，无法进行元素的填充
printArray(new int[3]);
}
/**
* 打印数组
* @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 i = 1;
System.out.println(i); // 1
// 调用方法
show(i); //
System.out.println(i); //
System.out.println("------------------------------");
int[] arr = { 1, 2, 3 };
printArray(arr); // [1,2,3]
// 调用方法
show(arr); // [3,4,5]
printArray(arr); // [3,4,5]
}
// 方法接收的是值类型的参数
// i为形参，它接受show方法调用时传递过来的实参
// show方法中使用的i叫做局部变量，声明该局部变量的地方是形参定义的地方，也是它的作用域开始的地方，作用域结束的地方是show方法右侧的大括号
public static void show(int i) {
i += 2;
System.out.println("方法内的参数值为：" + i);
}
// 方法接收的是引用类型的参数
// 传递引用类型的参数，其实传递的是堆内存中开辟的空间的地址（也就是所谓的把引用传递了过去）
public static void show(int[] arr) {
// 遍历数组
for (int i = 0; i < arr.length; i++) {
arr[i] += 2;
}
// 打印数组
printArray(arr);
}
/**
* 打印数组
* @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 Sample06 {
public static void main(String[] args) {
// 可变长参数：Java中当作数组处理
// 可变长参数一般出现在方法的形参中
// 调用方法
show(1, new double[] { 2, 3, 4 });
double[] arr = { 5, 6, 7 };
show(9, arr);
}
// 正确形式使用可变长参数
public static void show(int i, double... ds) {
System.out.println(i); //
System.out.println(ds); // [D@15db9742
System.out.println(ds.length); // 3
// 遍历
for (double item : ds) {
System.out.println(item);
}
}
// 注意：一个方法只能有一个可变长参数，且必须位于参数列表的最后位置
// 语法错误：The variable argument type double of the method test must be the last parameter
// public static void test(int i, double... ds, char... ch) {
// // 想创建多个可变长参数的方法
// }
// 语法错误：The variable argument type double of the method test must be the last parameter
// public static void test(int i, double... ds, boolean flag) {
// // 想创建可变长参数不在最后位置的方法
// }
}
package cn.temptation;
public class Sample07 {
public static void main(String[] args) {
// 排序
// 冒泡排序（两两位置比较，每轮最大数字出现在右侧，依次向左）
// 思路：
// 1、第一轮，比较第1个位置和第2个位置上的数，将较小的数放在第1个位置上，较大的数放在第2个位置上
// 比较第2个位置和第3个位置上的数，将较小的数放在第2个位置上，较大的数放在第3个位置上
// 以此类推直到第一轮结束（最后一个位置不用参与比较，因为它的右侧没有位置了）,最大的数字在最右侧
// 2、第二轮，还是比较第1个位置和第2个位置上的数，将较小的数放在第1个位置上，较大的数放在第2个位置上
// 比较第2个位置和第3个位置上的数，将较小的数放在第2个位置上，较大的数放在第3个位置上
// 以此类推直到第二轮结束（倒数第二个位置不用参与比较，因为它的右侧已经是最大的数了），第二大的数字在倒数第二个
// 3、后续的轮以此类推
int[] arr = { 2, 1, 0, 4, 3 };
System.out.println("排序前：");
printArray(arr);
// 冒泡排序算法
for (int i = 0; i < arr.length - 1; i++) { // 外层循环的轮数是数组长度 - 1，i表示的是当前为第几轮
for (int j = 0; j < arr.length - 1 - i; j++) { // j表示的当前轮中的位置
// 相邻的两个位置上的数做比较
if (arr[j] > arr[j + 1]) {
// 对调
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
// 可以使用打印数组的方法查看当轮排序结果
printArray(arr);
}
System.out.println("排序后：");
printArray(arr);
}
/**
* 打印数组
* @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) {
// 排序
// 选择排序
// 思路：
// 1、第一轮，把在第一个位置上的元素依次和后续位置上的元素进行比较，如果被比较的元素比第一个位置上的元素小，就对调，直到比较到最后一个位置上的元素
// 第一轮操作完成后，在第一个位置上得到最小的那个元素
// 2、第二轮，把在第二个位置上的元素依次和后续位置上的元素进行比较，如果被比较的元素比第二个位置上的元素小，就对调，直到比较到最后一个位置上的元素
// 第二轮操作完成后，在第二个位置上得到次小的那个元素
// 3、以此类推
int[] arr = { 2, 1, 0, 4, 3 };
System.out.println("排序前：");
printArray(arr);
// 选择排序算法
for (int i = 0; i < arr.length - 1; i++) { // 外层循环的i既表示轮数，又表示比较的位置
// 第一轮，把在第一个位置上的元素依次和后续位置上的元素进行比较，如果被比较的元素比第一个位置上的元素小，就对调，直到比较到最后一个位置上的元素
// if (arr[0] > arr[1]) {
// // 对调
// int temp = arr[0];
// arr[0] = arr[1];
// arr[1] = temp;
// }
// if (arr[0] > arr[2]) {
// // 对调
// int temp = arr[0];
// arr[0] = arr[2];
// arr[2] = temp;
// }
// 归纳上述语句，可以得到规律
for (int j = i + 1; j < arr.length; j++) { // 内层循环的j表示其他被比较的位置
if (arr[i] > arr[j]) {
// 对调
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
// 可以使用打印数组的方法查看当轮排序结果
printArray(arr);
}
System.out.println("排序后：");
printArray(arr);
}
/**
* 打印数组
* @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 Sample09 {
public static void main(String[] args) {
// 排序
// 插入排序
// 思路：
// 1、第一轮，从第2个位置开始，和其左侧的紧靠着它的位置的数（第1个位置上的数）进行比较，小的数放前面，大的数放后面
// 2、第二轮，从第3个位置开始，和其左侧的紧靠着它的位置的数（第2个位置上的数）进行比较，小的数放前面，大的数放后面
// 再看第2个位置，和其左侧的紧靠着它的位置的数（第1个位置上的数）进行比较，小的数放前面，大的数放后面
// 3、第三轮，从第4个位置开始，和其左侧的紧靠着它的位置的数（第3个位置上的数）进行比较，小的数放前面，大的数放后面
// 再看第3个位置，和其左侧的紧靠着它的位置的数（第2个位置上的数）进行比较，小的数放前面，大的数放后面
// 再看第2个位置，和其左侧的紧靠着它的位置的数（第1个位置上的数）进行比较，小的数放前面，大的数放后面
// 4、以此类推
int[] arr = { 2, 1, 0, 4, 3 };
System.out.println("排序前：");
printArray(arr);
// 插入排序算法
for (int i = 1; i < arr.length; i++) { // 外层循环的i既表示轮数，又表示位置
// // 第一轮操作
// if (arr[0] > arr[1]) {
// // 对调
// int temp = arr[0];
// arr[0] = arr[1];
// arr[1] = temp;
// }
//
// // 第二轮操作
// if (arr[1] > arr[2]) {
// // 对调
// int temp = arr[1];
// arr[1] = arr[2];
// arr[2] = temp;
// }
// if (arr[0] > arr[1]) {
// // 对调
// int temp = arr[0];
// arr[0] = arr[1];
// arr[1] = temp;
// }
// 归纳上述操作，得到规律
// 写法一
for (int j = i; j > 0; j--) { // 内层循环的j表示当前的这个位置
if (arr[j] < arr[j - 1]) { // // 内层循环的当前的这个位置上的数 和 其左侧紧靠着它的位置上的数进行比较
// 对调
int temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
}
}
// 写法二
// for (int j = 0; j < i; j++) { // 内层循环的j表示从第1个位置开始配合进行比较
// if (arr[j] > arr[i]) {
// // 对调
// int temp = arr[i];
// arr[i] = arr[j];
// arr[j] = temp;
// }
// }
}
System.out.println("排序后：");
printArray(arr);
}
/**
* 打印数组
* @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;
import java.util.Arrays;
public class Sample10 {
public static void main(String[] args) {
// 初始化数组
int[] arr = { 2, 1, 0, 4, 3 };
System.out.println("排序前：");
printArray(arr);
// 可以调用Arrays类的sort方法进行排序
// 类 Arrays：此类包含用来操作数组（比如排序和搜索）的各种方法。
// 常用的成员方法：
// static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。
Arrays.sort(arr);
System.out.println("排序后：");
printArray(arr);
}
/**
* 打印数组
* @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();
}
}
【原】Java学习笔记011 - 数组的更多相关文章
- 【原】Java学习笔记012 - 数组
package cn.temptation; public class Sample01 { public static void main(String[] args) { // 需求:小店对自己的 ...
- 【原】Java学习笔记010 - 数组
package cn.temptation; public class Sample01 { public static void main(String[] args) { // 需求:一堆分数,要 ...
- 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学习笔记之数组
随机推荐
- 机器学习入门 - Google机器学习速成课程 - 笔记汇总
机器学习入门 - Google机器学习速成课程 https://www.cnblogs.com/anliven/p/6107783.html MLCC简介 前提条件和准备工作 完成课程的下一步 机器学 ...
- Saiku嵌入系统使用时传参数访问saiku(十六)
Saiku嵌入系统使用时传参数访问saiku Saiku通过iframe嵌入其他系统使用时,我们可以设定参数信息,然后根据url中参数对结果进行筛选哦. 这里我们实现的是根据日期字段进行范围查询,UR ...
- 本地连接虚拟机_环境搭建01_VMWARE/XShell/CentOS
今天起准备搭建一套环境用来学习redis,dubbo,docker,nginx. 环境准备: 1.VMware12: https://pan.baidu.com/s/1-LnqfrWw8ZjQdmG ...
- Java面向对象--类的对象之间的几种关系详解
转载: https://www.cnblogs.com/supren/p/7853377.html
- slf4j 和 log4j的关系及合用Maven配置
最近因为项目实在是太忙,都没有时间学习.有时候会很矛盾,一方面是全心全意的想去快速做完项目,一方面又想学习点新东西.这样导致这两三个月都没有去学习一些新的东西,这周我开始创建自己的maven项目,因为 ...
- python-redistest
# !/usr/bin/python3.4 # -*- coding: utf-8 -*- import redis import time # 这里用来读取ip def getips(): ip = ...
- 6.jQuery(实例)
1.开关灯效果 <!DOCTYPE html> <html lang="en"> <head> <meta charset="U ...
- IdentityServer4实战 - API与IdentityServer的交互过程解析
开局一张图,内容全靠看.如有不明白的地方可在评论里说出,后面我再加上.
- Android中，粗暴的方式，修改字体
序 在 Android 下使用自定义字体已经是一个比较常见的需求了,最近也做了个比较深入的研究. 那么按照惯例我又要出个一篇有关 Android 修改字体相关的文章,但是写下来发现内容还挺多的,所以我 ...
- Spring中bean实例化的三种方式
之前我已经有好几篇博客介绍Spring框架了,不过当时我们都是使用注解来完成注入的,具体小伙伴可以参考这几篇博客(Spring&SpringMVC框架案例).那么今天我想来说说如何通过xml配 ...