Java基础篇
2021/9/4 14:36:06
本文主要是介绍Java基础篇，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
Java基础知识 第4天
【学习目标】理解、了解、应用、记忆
1. 【应用】IDEA工具的安装及使用
a) 【应用】掌握idea开发工具的安装
b) 【应用】能够使用idea创建Java工程
c) 【应用】能够使用idea创建包和类
d) 【了解】idea的Java工程目录
e) 【了解】idea字体的设置
f) 【应用】idea常用开发快捷键
g) 【了解】项目的导入和删除
2. 【理解】一维数组内存结构及静态初始化
a) 【记忆】能够阐述Java中的内存划分哪几块区域
b) 【理解】能够根据代码阐述一个数组在内存中的分布图
c) 【理解】能够根据代码阐述两个数组在内存中的分布图
d) 【理解】能够根据代码阐述两个数组指向同一个地址值的内存图
e) 【应用】能够独立写出数组初始化之静态初始化
3. 【应用】一维数组常见问题及练习
a) 【应用】能够独立写出数组操作的两个常见小问题的代码
b) 【应用】能够独立编写数组操作之遍历数组的代码
c) 【应用】能够独立编写数组操作之获取最值的代码
4.【理解】二维数组的定义和使用
a) 【理解】能够阐述二维数组的概述和基本使用
b) 【应用】能够独立编写二维数组遍历代码
5.【应用】Arrays数组的工具类
a) 【应用】Arrays的API使用
b) 【了解】快速排序原理的解析
c) 【应用】冒泡排序实现
d) 【理解】折半查找法
e) 【应用】数组拷贝及扩容
第1章 开发工具IntelliJ IDEA的使用
1.1 开发工具概述
IDEA是一个专门针对Java的集成开发工具(IDE)，由Java语言编写。所以，需要有JRE运行环境并配置好环境变量。 它可以极大地提升我们的开发效率。可以自动编译，检查错误。在公司中，使用的就是IDEA进行开发。
1.2 IDEA软件安装
此软件集成了32位和64位，双击 ideaIU-2019.2.4.exe 进入安装。
**PS:**破解详情见《IDEA开发工具安装及使用.pdf》文件
1.3 IDEA常用快捷键
Alt+Enter 导入包，自动修正代码
Ctrl+Y 删除光标所在行
Ctrl+D 复制光标所在行的内容，插入光标位置下面
Ctrl+Alt+L 格式化代码
Ctrl+/ 单行注释
Ctrl+Shift+/ 选中代码注释，多行注释，再按取消注释
Alt+Ins 自动生成代码，toString，get，set等方法
Alt+Shift+上下箭头 移动当前代码行
1.4 字体设置
IDEA工具的默认字体非常小，代码编辑器和控制台的输出字体都需要进行调整。
点击菜单栏上的 File->Settings->Editor->Font 修改字体。
1.5 IDEA的项目目录
我们创建的项目，在项目所在目录的demo下
.idea 目录和 demo.iml 与开发无关，是IDEA工具自己使用的
out 目录是存储编译后的.class文件
src 目录是存储我们编写的.java源文件
1.6 IDEA修改快捷键
在IDEA工具中， Ctrl+空格 的快捷键，可以帮助我们补全代码，但是这个快捷键和Windows中的输入法切换快捷 键冲突，需要修改IDEA中的快捷键。
1. File->Settings->keymap->Main menu->code->Completion->Basic
2.双击 Basic->remove->Ctrl+空格
3.双击 Basic->Add Keyboard->键入 Alt+/->点击OK
1.7 IDEA导入和关闭项目
1.关闭IDEA中已经存在的项目
File->Close Project
File->Close Project后，此时IDEA回到了刚启动界面，点击项目上的 X ，IDEA中就没有这个项目了
2.在IDEA的启动界面上，点击 OPEN ，选择项目目录打开即可
3.若想通过IDEA同时开启多个项目，点击OPEN打开项目时，点击New Window按钮
第2章 数组
/**
* 数组的概念：存放一组相同数据类型的容器，且长度固定
*
* 数组的特点：
* 1.数组本身是引用数据类型
* 2.数组中允许存放基本数据类型、引用数据类型
* 3.长度一经定义，无法修改
* 4.存放相同数据类型的元素
*
*
* 一维数组
* 1.如何声明？
* 1.1 int[] arr = new int[3];
* 1.2 String[] strs = {"aaa","bbb","ccc","ddd"};
* 2.如何赋值？
* 2.1 声明时直接赋值 int[] arr = {10,20,30};
* 2.2 通过下标进行赋值 语法：数组名[下标] = 值;
* 3.如何取值？
* 3.1 通过下标进行取值 for(变量初始化;变量<数组.length;变量++){ //数组名[下标] }
* 3.2 迭代器取值 for(数组中元素类型 临时变量名 : 数组名) { //临时变量名 } 后期使用较多的情况
*/
public class OneArrayDemo1 {
public static void main(String[] args) {
/*
声明方式一：指定数组的长度
1.arr1数组中的元素都是int数据类型，基本数据类型
2.arr1数组中可以存放3个元素
3.arr1数组中元素的默认值都是0
4.arr1对象，int的一维数组类型，引用数据类型
*/
int[] arr1 = new int[3]; //下标范围：0~len-1
//通过下标赋值
arr1[0] = 52;
arr1[1] = 46;
//通过下标取值 .sout直接生成打印输出 ctrl+d复制上一行
System.out.println(arr1[0]); //52
System.out.println(arr1[1]); //46
System.out.println(arr1[2]); //0
//System.out.println(arr1[3]); //数组下标越界异常 ArrayIndexOutOfBoundsException: 3
System.out.println("-----------fori---------------");
/*
声明方式二：指定数组中的元素
1.strs数组中的元素都是String字符串类型，引用数据类型
2.strs数组中存放4个元素
3.strs对象，String的一维数组类型，引用数据类型
*/
String[] strs = {"aaa","bbb","ccc","ddd"};
//迭代方式一：通过下标操作 数组名.fori 快捷生成数组的迭代
for (int i = 0; i < strs.length; i++) {
//i数组的下标 数组名[下标]
System.out.println(strs[i]);
}
System.out.println("-----------foreach---------------");
//迭代方式二：加强for循环 foreach 数组名.for 快捷生成数组的迭代
for (String str : strs) { //for(数组中元素类型 临时变量名 : 数组名){ //临时变量名，即数组中的每一个元素 }
System.out.println(str);
}
}
}
2.1 数组概述
**容器：**是将多个数据存储到一起，每个数据称为该容器的元素。
那么数组到底是什么呢?有什么特点呢?
数组是存储多个变量(元素)的东西(容器)
这多个变量的数据类型要一致
数组概念： 数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。
数组特点：
1.数组长度固定
2.数组容器中存储元素的数据类型一致
2.2 数组的定义格式
2.2.1 数组概念
数组是存储同一种数据类型多个元素的容器。
数组既可以存储基本数据类型，也可以存储引用数据类型。
2.2.2 数组的定义格式
格式1：数据类型[] 数组名; int[] arr;
格式2：数据类型 数组名[];
注意：这两种定义做完了，数组中是没有元素值的。
2.3 数组的初始化
2.3.1 数组初始化概述
Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
2.3.2 数组的初始化方式
2.3.2.1 动态初始化:初始化时只指定数组长度，由系统为数组分配初始值
格式：数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
2.3.2.2 案例一
//数组：存储同一种数据类型的多个元素的容器。
//动态初始化：数据类型[] 数组名 = new 数据类型[数组长度];
public class ArrayDemo1 {
public static void main(String[] args) {
//数据类型[] 数组名 = new 数据类型[数组长度]; 数组中的元素默认值为0
int[] arr = new int[3];
/*
* 左边：
* int:说明数组中的元素的数据类型是int类型
* []:说明这是一个数组
* arr:是数组的名称
* 右边：
* new:为数组分配内存空间
* int:说明数组中的元素的数据类型是int类型
* []:说明这是一个数组
* 3:数组的长度，其实就是数组中的元素个数
*/
}
}
2.3.2.3 静态初始化:初始化时指定每个数组元素的初始值，由元素个数决定数组长度
格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
格式：数据类型[] 数组名 = {元素1,元素2,元素3...};
2.3.2.4 案例二
//静态初始化的格式
//数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
//简化格式：数据类型[] 数组名 = {元素1,元素2,...};
public class ArrayDemo2 {
public static void main(String[] args) {
//定义数组
int[] arr1 = new int[]{1,2,3};
int[] arr2 = {1,2,3};
}
}
2.4 数组的内存分配
**内存概述：**内存是计算机中的重要原件，临时存储区域，作用是运行程序。我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。
2.4.1 JVM内存划分
Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈 存储局部变量。 - 局部变量即定义在方法内部的变量 - 使用完毕立即回收。 堆 存储new出来的东西，真正的对象。 - 每个对象都有首地址 - 每个对象的数据都有默认值 - 使用结束后会被垃圾回收器在空闲的时候回收
2.4.2 一个数组的内存图
需求：定义一个数组，输出数组名及元素。然后给数组中的元素赋值，再次输出数组名及元素。
2.4.2.1 案例三
/**
* 需求：定义一个数组，输出数组名及元素。然后给数组中的元素赋值，再次输出数组名及元素。
*/
public class ArrayTest1 {
public static void main(String[] args) {
//定义一个数组
int[] arr = new int[3];
//输出数组名及元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
//给数组中的元素赋值
arr[0] = 100;
arr[2] = 200;
//再次输出数组名及元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
2.4.2.2 代码内存图解
2.4.3 两个数组的内存图
需求：定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素
2.4.3.1 案例四
/**
* 需求：定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素。
*/
public class ArrayTest2 {
public static void main(String[] args) {
//定义两个数组
int[] arr = new int[2];
int[] arr2 = new int[3];
//分别输出数组名及元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
//然后分别给数组中的元素赋值
arr[1] = 100;
arr2[0] = 200;
arr2[2] = 300;
//再次输出数组名及元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
}
}
2.4.3.2 代码内存图解
2.4.4 两个数组指向同一个地址的内存图
需求：定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。然后给第二个数组赋值，再次输出两个数组的名及元素
//两个数组指向同一块地址
public class OneArrayDemo2 {
public static void main(String[] args) {
int[] arr = new int[3];
//数组间的赋值，赋的是地址，即两个数组指向的是同一块地址
int[] brr = arr;
brr[0] = 10;
System.out.println("arr[0] = "+arr[0]);
System.out.println("brr[0] = "+brr[0]);
}
}
2.4.4.1 案例五
/**
* 需求：定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数
* 组。然后给第二个数组赋值，再次输出两个数组的名及元素。
*/
public class ArrayTest3 {
public static void main(String[] args) {
// 先定义一个数组，赋值，输出
int[] arr = new int[3];
arr[0] = 100;
arr[1] = 200;
arr[2] = 300;
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
// 然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组
int[] arr2 = arr;
// 然后给第二个数组赋值
arr2[0] = 111;
arr2[1] = 222;
arr2[2] = 333;
// 再次输出两个数组的名及元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
}
}
2.4.4.2 代码内存图解
2.5 数组的使用
2.5.1 数组的元素访问
索引： 每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引 (index)，可以通过数组的索引访问到数组中的元素。
格式： 数组名[索引]
数组的长度属性： 每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的长度，语句为： 数组名.length ，属性length的执行结果是数组的长度，int类型结果。
数组的最大索引值为：数组名.length-1 。
索引访问数组中的元素：
数组名[索引]=数值，为数组中的元素赋值
变量=数组名[索引]，获取出数组中的元素
2.5.2 案例六
public class ArrayDemo3 {
public static void main(String[] args) {
//数据类型[] 数组名 = new 数据类型[数组长度];
int[] arr = new int[3];
//[I@3fa5ac,地址值
System.out.println(arr);
//我们获取到地址值没有意义，我要的是数组中的数据值，该怎么办呢?
//不用担心，java已经帮你想好了
//其实数组中的每个元素都是有编号的，编号是从0开始的，最大的编号就是：数组的长度-1
//用数组名和编号的配合我们就可以获取数组中的指定编号的元素，这个编号的专业叫法：索引
//格式：数组名[编号] <--> 数组名[索引]
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
2.5.3 数组使用的两个小问题
ArrayIndexOutOfBoundsException 数组越界异常
NullPointerException 空指针异常
2.5.4 案例七
/**
* 数组越界异常、空指针异常
*
* 两个常见小问题：
* A:java.lang.ArrayIndexOutOfBoundsException
* 数组越界异常
* 产生的原因：就是你访问了不存在的索引元素。
* B:java.lang.NullPointerException
* 空指针异常
* 产生的原因：数组已经不指向堆内存的数据了，你还使用数组名去访问元素。
*
* 为什么我们要记住这样的小问题呢?
* 编程不仅仅是把代码写出来，还得在出现问题的时候能够快速的解决问题。
*/
public class ArrayDemo4 {
public static void main(String[] args) {
// 定义数组
int[] arr = {1, 2, 3};
//ArrayIndexOutOfBoundsException 数组越界异常
//System.out.println(arr[3]);
//引用类型：类,接口,数组
//常量：空常量 null，是可以赋值给引用类型的
//arr = null;
System.out.println(arr[1]);
}
}
2.5.5 数组的迭代
需求：声明数组，迭代遍历(依次输出数组中的每一个元素)，获取数组中元素的个数：数组名.length
2.5.6 案例八
public class ArrayDemo5 {
public static void main(String[] args){
//申明数组，创建数组
int[] arry = new int[]{1,2,3,4,5};
//取值
/* System.out.println(i[0]);
System.out.println(i[1]);
System.out.println(i[2]);
System.out.println(i[3]);
System.out.println(i[4]);
*/
//第一种：for循环，迭代取值
for(int j = 0;j < arry.length;j++){
System.out.println(arry[j]);
}
//第二种：for循环，加强for
for(int x : arry){
System.out.println(x);
}
}
}
2.6 一维数组的课堂练习
//练习1：需求：定义整型数组，从键盘输入5个元素，并求其最大值
//练习2：有一个数列：8,4,2,1,23,344,12，此时从键盘中任意输入一个数据，判断数列中是否包含此数
//方法一
//方法二：先冒泡排序，再折半查找出是否包含
//练习3：把一个数组元素逆序交换，int[] a ={5,11,15,24,36,47,59,66}; 交换元素后int[] a = {66,59,47,36,24,15,11,5}
//练习1：需求：定义整型数组，从键盘输入5个元素，并求其最大值
public class OneArrayTest1 {
public static void main(String[] args) {
//1.定义整型数组
int[] arr = new int[5]; //默认值为0
//2.从键盘输入5个元素
Scanner scanner = new Scanner(System.in);
System.out.println("请输入五个元素：");
for (int i = 0; i < arr.length; i++) { //i下标
arr[i] = scanner.nextInt(); //数组赋值：数组名[下标]=值
}
//输出
for(int a:arr){
System.out.print(a+"\t");
}
//3.求其最大值
int max = arr[0]; //将数组中的第一个元素作为最大值
for(int i=1;i<arr.length;i++){ //i下标
if(max<arr[i]){
max = arr[i];
}
}
System.out.println("最大值 max = "+max);
}
}
//练习2：有一个数列：8,4,2,1,23,344,12，此时从键盘中任意输入一个数据，判断数列中是否包含此数(第一种方法)
public class OneArrayTest2 {
public static void main(String[] args) {
//1.定义一个一位数组
int[] arr = {8,4,2,1,23,344,12};
//2.从键盘中任意输入一个数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个数据：");
int m = sc.nextInt();
//3.判断数列中是否包含此数
boolean flag = true; //标识符
for(int a:arr){
if(m == a){
System.out.println("包含");
flag = false;
break;
}
}
if(flag){
System.out.println("不包含");
}
}
}
//练习2：有一个数列：8,4,2,1,23,344,12，此时从键盘中任意输入一个数据，判断数列中是否包含此数(第二种方法)
public class BinaryDemo {
public static void main(String[] args) {
//1.定义一个数组
int[] arr = {8,4,2,1,23,344,12};
//2.对数组进行排序
Arrays.sort(arr);//使用Arrays工具类的快速排序
System.out.println("排序后："+Arrays.toString(arr)); //使用Arrays工具类的toString打印输出
//3.折半查找法查询
int left = 0;
int right = arr.length-1;
int middle = 0;
Scanner scanner = new Scanner(System.in);
System.out.println("请输入查询数据：");
int key = scanner.nextInt();
boolean flag = true;
while(left<=right){
//计算中间位置的值middle
middle = (left+right)/2;
if(key > arr[middle]){ //考虑middle的右边
left = middle + 1;
}else if(key < arr[middle]){ //考虑middle的左边
right = middle - 1;
}else if(arr[middle] == key){
System.out.println("包含");
flag = false;
break;
}
}
if(flag){
System.out.println("不包含");
}
}
}
//练习3：把一个数组元素逆序交换，int[] arr ={5,11,15,24,36,47,59,66};
//交换元素后int[] arr = {66,59,47,36,24,15,11,5}
public class OneArrayTest3 {
public static void main(String[] args) {
int[] arr = {5,11,15,24,36,47,32,59,66};
for(int i=0;i<arr.length/2;i++){ //i 0~3
//arr[i]前置位的值 arr[arr.length-1-i]后置位的值
int temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
for (int a : arr) {
System.out.print(a+"\t");
}
}
}
2.7 二维数组
/**
* 二维数组的概念：容器，二维数组中的元素就是一维数组
*
* 1.二维数组的声明
* 1.1 直接指定长度
* int[][] arr1 = new int[2][];
* int[][] arr2 = new int[2][3];
* 1.2 直接指定元素
* int[] a = {1,2,3};
* int[] b = {10,20,30};
* int[][] arr3 = {a,b};
* int[][] arr4 = { {1,2,3} , {10,20,30} };
*
* 2.二维数组的赋值
*
* 3.二维数组的取值
*/
public class TwoArrayDemo {
public static void main(String[] args) {
//方式一：指定长度
int[][] arr1 = new int[2][];
int[][] arr2 = new int[2][3];
//第一个维度赋值
arr1[0] = new int[2];
arr1[1] = new int[3];
//第二个维度赋值
arr1[0][1] = 15;
arr1[1][0] = 25;
//取值
for(int i=0;i<arr1.length;i++){ //i 行 第一个维度的长度
for(int j=0;j<arr1[i].length;j++){ //j 列 第二个维度的长度
System.out.print(arr1[i][j]+"\t");
}
System.out.println();
}
System.out.println("===========================");
//方式二：指定元素
int[] a = {1,2,3};
int[] b = {10,20,30};
int[][] arr3 = {a,b};
int[][] arr4 = {{1,2,3},{10,20,30,40},{11,22}};
for(int i=0;i<arr4.length;i++){ //i 行 arr4.length
for(int j=0;j<arr4[i].length;j++){ //j 列 arr4[i].length
System.out.print(arr4[i][j]+"\t");
}
System.out.println();
}
}
}
2.7.1 二维数组概述
我们极客营程序员的Java基础班每个班有很多个学生，所以，可以用数组来存储，而我们又同时有很多个Java基础班。这个也应该用一个数组来存储。如何来表示这样的数据呢？Java就提供了二维数组供我们使用。
由此可见：其实二维数组其实就是一个元素为一维数组的数组。
2.7.2 二维数组格式
定义格式： 数据类型[][] 数组名; 数据类型 数组名[][]; 不推荐 数据类型[] 数组名[]; 不推荐
初始化方式：
//动态初始化：
//m表示这个二维数组有多少个一维数组
//n表示每一个一维数组的元素有多少个
数据类型[][] 变量名 = new 数据类型[m][n];
//静态初始化:
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
//简化版格式：
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
2.7.2.1 案例九
public class TwoArrayDemo1 {
public static void main(String[] args) {
// 数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...};
int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
System.out.println(arr); // [[I@104c575
System.out.println(arr.length); // 二维数组中的一维数组的个数
System.out.println(arr[0]);// [I@3fa5ac
System.out.println(arr[0].length);
System.out.println(arr[1]);// [I@95cfbe
System.out.println(arr[2]);// [I@179dce4
//我如何获取到一个二维数组的元素呢?
System.out.println(arr[0][0]);
System.out.println(arr[1][1]);
System.out.println(arr[2][0]);
}
}
2.7.3 二维数组的遍历
遍历思想:首先使用循环遍历出二维数组中存储的每个一维数组,然后针对每个遍历到的一维数组在使用循环遍历该一维数组中的元素
2.7.3.1 案例十
public class TwoArrayDemo2 {
public static void main(String[] args) {
//定义二维数组
int[][] arr={{1,2,3},{4,5,6},{7,8,9}};
//二维数组中的一维数组名：二维数组名[索引]
//arr[0] 其实就是二维数组中的第一个一维数组的名称
//arr[1] 其实就是二维数组中的第二个一维数组的名称
//arr[2] 其实就是二维数组中的第三个一维数组的名称
/* //第一个一维数组的元素
for(int x=0;x<arr[0].length;x++){
System.out.println(arr[0][x]);
}
//第二个一维数组的元素
for(int x=0;x<arr[1].length;x++){
System.out.println(arr[1][x]);
}
//第三个一维数组的元素
for(int x=0;x<arr[2].length;x++){
System.out.println(arr[2][x]);
}*/
//改进代码，二维数组的长度
for(int y=0;y<arr.length;y++){
for(int x=0;x<arr[y].length;x++){
System.out.println(arr[y][x]);
}
}
System.out.println("---------------");
//最终改进
for(int y=0;y<arr.length;y++){
for(int x=0;x<arr[y].length;x++){
System.out.print(arr[y][x]+" ");
}
System.out.println();
}
}
}
2.8 二维数组的课堂练习
//练习1：用二维字符数组保存一首唐诗（五言或七言），每一行代表一句，要求将这首唐诗按照古文的方式输出出来（从右至左，竖行排列）。。。
public class TwoArrayTest1 {
public static void main(String[] args) {
char[][] cs = {
{'床','前','明','月','光','，'},
{'疑','是','地','上','霜','。'},
{'举','头','望','明','月','，'},
{'低','头','思','故','乡','。'}
};
for(int i=0;i<cs.length;i++){ //4行 6列
for(int j=0;j<cs[i].length;j++){
System.out.print(cs[i][j]+"\t");
}
System.out.println();
}
System.out.println("---------------------------");
for(int i=0;i<cs[0].length;i++){ //i 0~5 6行
for(int j=0;j<cs.length;j++){ //j 0~3 4列
System.out.print(cs[3-j][i]+"\t");
}
System.out.println();
}
System.out.println("------------第二种方式---------------");
for(int i=0;i<cs[0].length;i++){ //i 0~5 6行
for(int j=cs.length-1;j>=0;j--){ //j 0~3 4列 //逆序输出
System.out.print(cs[j][i]+"\t");
}
System.out.println();
}
}
}
//练习2：九宫格
3
08 01 06
03 05 07
04 09 02
5
17 24 01 08 15
23 05 07 14 16
04 06 13 20 22
10 12 19 21 03
11 18 25 02 09
import java.util.Scanner;
//九宫格
public class TwoArrayTest2 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入九宫格数（要求必须是>1的奇数）：");
int N = scanner.nextInt();
while (N<=1 || N%2==0){
System.out.println("请输入九宫格数（要求必须是>1的奇数）：");
N = scanner.nextInt();
}
//1.创建N*N的二维数组
int[][] arr = new int[N][N];
//2.第一个值的位置 第一行的正中间
int x = 0;
int y = N/2;
//3.循环判断赋值
for(int value=1;value<=N*N;value++){
//赋值
arr[x][y] = value;
//右上角
x--;
y++;
if(x<0 && y<N){ //行越界，列不越界
x = N-1; //当前列的最后一行
}else if(x>=0 && y>=N){ //列越界，行不越界
y = 0; //当前行的第一列
}else if((x<0&&y>=N) || arr[x][y]!=0){ //行列都越界，右上角有值
x+=2;
y--; //原数值的正下方
}
}
//4.输出
for (int i=0;i<arr.length;i++){
for (int j=0;j<arr[i].length;j++){
System.out.print((arr[i][j]<10?"0"+arr[i][j]:arr[i][j])+"\t");
}
System.out.println();
}
}
}
//练习3：二维数组3X3，求其对角线元素之和
public class TwoArrayTest3 {
public static void main(String[] args) {
//声明数组
int[][] arr = new int[3][];
//赋值
arr[0] = new int[]{1,2,3};
arr[1] = new int[]{4,5,6};
arr[2] = new int[]{7,8,9};
//求其对角线元素之和
int sum1 = 0;
int sum2 = 0;
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
//正对角线
if(i==j){
sum1+=arr[i][j];
}
//副对角线
if(i+j==2){
sum2+=arr[i][j];
}
}
}
System.out.println("sum1 = "+sum1);
System.out.println("sum2 = "+sum2);
}
}
第3章 Arrays类
3.1 Arrays 数组的工具类
3.2 快速排序原理的解析
3.3 实现冒泡排序
需求：从键盘输入十个整数，升序输出；（冒泡排序）
/**
* 冒泡排序
*/
public class BubbleDemo {
public static void main(String[] args) {
int[] arr = {8,4,2,1,23,344,12};
//i 比较轮数
for (int i = 0; i < arr.length-1; i++) {
//j 次数
for (int j = 0; j < arr.length-i-1 ; j++) {
//比较
if(arr[j]>arr[j+1]){
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
//输出
for (int a : arr) {
System.out.println(a);
}
}
}
3.4 折半查找法
需求：有一个数列：8,4,2,1,23,344,12，此时从键盘中任意输入一个数据，判断数列中是否包含此数
/**
* 二分查找法（折半查找法）：基于有序的数组
* 练习2：有一个数列：1,2,4,8,12,23,344，此时从键盘中任意输入一个数据，判断数列中是否包含此数
*/
public class BinaryDemo {
public static void main(String[] args) {
int[] arr = {1,2,4,8,12,23,344};
// 下标
int left = 0;
int right = arr.length - 1;
int middle = 0;
//key
Scanner scanner = new Scanner(System.in);
System.out.println("输入关键字：");
int key = scanner.nextInt();
boolean flag = true;
//只要满足此条件，可以一直循环比较
while(left <= right){
//计算middle
middle = (left+right)/2;
//比较 将key与arr[middle]进行比较
if(arr[middle] > key){
right = middle - 1;
}else if(arr[middle] < key){
left = middle + 1;
}else if(arr[middle] == key){
flag = false;
System.out.println("包含");
break;
}
}
if(flag){
System.out.println("不包含");
}
}
}
3.5 数组拷贝及扩容
/**
* Arrays 数组工具类 拷贝
*/
public class ArraysDemo1 {
public static void main(String[] args) {
/**
* System
* src 源数组 srcPos 源数组的起始位置 dest目标数组 destPos目标数组的起始位置 length 拷贝长度
* static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
*/
int[] arr = {10,25,3,45,12};
int[] brr = new int[arr.length];
System.arraycopy(arr,0,brr,0,arr.length);
System.out.println("arr:"+Arrays.toString(arr));
System.out.println("brr:"+Arrays.toString(brr));
//equals比较两个数组中的元素内容
System.out.println(Arrays.equals(arr,brr)); //true
//== 比较的地址
System.out.println(arr == brr); //false
/**
* Arrays
* original 源数组 newLength 新数组的长度
* static int[] copyOf(int[] original, int newLength)
*/
int[] crr = Arrays.copyOf(arr, arr.length);
System.out.println("crr:"+Arrays.toString(crr));
System.out.println("equals:"+Arrays.equals(arr,crr)); //true
System.out.println("==:"+(arr==crr)); //false
//数组扩容
int[] drr = Arrays.copyOf(arr, arr.length*3/2+1);
int[] err = Arrays.copyOf(drr, drr.length*3/2+1);
System.out.println("drr:"+Arrays.toString(drr));
System.out.println("err:"+Arrays.toString(err));
}
}
3.6 API中其它方法
/**
* Arrays工具类 排序 二分法
*/
public class ArraysDemo2 {
public static void main(String[] args) {
int[] arr = {10,25,9,12,11,7};
/**
* 先排序
* static void sort(int[] a)
* 第一个参数：参与排序的数组 第二个参数：起始位置 第三个参数：终止位置（取不到）
* static void sort(int[] a, int fromIndex, int toIndex)
*/
Arrays.sort(arr);
//Arrays.sort(arr,1,4);
System.out.println(Arrays.toString(arr)); //[7, 9, 10, 11, 12, 25]
/**
* 再二分搜索
* static int binarySearch(int[] a, int key)
* 使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。
* static int binarySearch(int[] a, int fromIndex, int toIndex, int key)
* 使用二分搜索法来搜索指定的 int 型数组的范围，以获得指定的值。
*
* 返回值：
* 1.若包含，则直接返回下标
* 2.若不包含，且元素大于数组中所有值，则插入点为数组的长度，返回下标(-arr.length)-1
* 3.若不包含，且元素不大于数组中所有值，则插入点为第一个大于key的元素下标，返回下标(-index)-1
*/
int index = Arrays.binarySearch(arr,8);
System.out.println(index);
}
}
/**
* Arrays工具类 深层迭代 填充元素
*/
public class ArraysDemo3 {
public static void main(String[] args) {
//deepToString 深层迭代
int[][] arr = {{1,2,3},{4,5,6,7}};
System.out.println(Arrays.toString(arr)); //地址
System.out.println(Arrays.deepToString(arr)); //元素的数值
//static void fill(Object[] a, Object val) 填充元素
String[] strs = new String[5];
Arrays.fill(strs,"aaa");
System.out.println(Arrays.toString(strs)); //[aaa,aaa,aaa,aaa,aaa]
//static void fill(Object[] a, int fromIndex, int toIndex, Object val) 指定范围填充元素
Arrays.fill(strs,1,4,"bbb");
System.out.println(Arrays.toString(strs)); //[aaa,bbb,bbb,bbb,aaa]
}
}
这篇关于Java基础篇的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
- 2024-11-28MQ底层原理资料详解：新手入门教程
- 2024-11-28MQ项目开发资料详解：新手入门教程
- 2024-11-28MQ项目开发资料详解：入门与初级用户指南
- 2024-11-28MQ消息队列资料入门教程
- 2024-11-28MQ消息队列资料：新手入门详解
- 2024-11-28MQ消息中间件资料详解与应用教程
- 2024-11-28MQ消息中间件资料入门教程
- 2024-11-28MQ源码资料详解与入门教程
- 2024-11-28MQ源码资料入门教程
- 2024-11-28RocketMQ底层原理资料详解
