JavaSE第三章
文章目录
数组的基本概念及作用
数组是相同数据类型元素的集合
数组本身是引用数据类型,即对象。但是数组可以存储基本数据类型,也可以存储引用数据类型。
总结:
Java数组:存储一组相同类型的数据
数组是一个连续的存储空间,当数组的长度一旦确定,就不能改变了。
数组属于引用数据类型(也可以说数组属于对象)
数据可以存储基本数据类型,也可以存储引用类型
数组的声明与创建
import java.util.Arrays;
/**
* @author 辉欲静,而风止。
* 动态数组
* @date 2021年7月21日08:59:20
*/
public class DynamicArray {
public static void main(String[] args) {
/*
声明数组
X[] a;数组a X表示数组中可以存储数据的数据类型
*/
//动态创建 整型数组
int[] array = new int[5];
System.out.println(Arrays.toString(array));
//长整型
long[] longs = new long[5];
System.out.println(Arrays.toString(longs));
//字符型数组
char[] chars = new char[5];
System.out.println(Arrays.toString(chars));
//字符串型数组
String[] strings = new String[5];
System.out.println(Arrays.toString(strings));
// 布尔型数组
boolean[] booleans = new boolean[5];
System.out.println(Arrays.toString(booleans));
//静态创建的两种方式
//当数量已知,或者数量确定时 建议使用第二种方式进行静态创建
int[] b1 = new int[]{1,2,3};
System.out.println(Arrays.toString(b1));
int[] b2 ={1,2,3,5,9};
System.out.println(Arrays.toString(b2));
}
}
运行结果:
[0, 0, 0, 0, 0]
[0, 0, 0, 0, 0]
[ , , , , ]
[null, null, null, null, null]
[false, false, false, false, false]
[1, 2, 3]
[1, 2, 3, 5, 9]
数组的访问与迭代
package com.sxlg.blog.note_array;
import java.util.Arrays;
public class Traitarray {
public static void main(String[] args) {
/*
数组元素的访问:通过索引下标访问
索引的特点:index
整数
从零开始,到数组长度-1
*/
int[] b2 ={1,2,3,5,9};
// 数组长度为五 下标范围既是从0到数组长度-1 数组下标 从0--4
System.out.println(Arrays.toString(b2));
System.out.println(b2[0]);
System.out.println(b2[2]);
//ArrayIndexOutOfBoundsException 数组越界
System.out.println(b2[5]);
}
}
运行结果:
[1, 2, 3, 5, 9]
1
3
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
at com.sxlg.blog.note_array.Traitarray.main(Traitarray.java:17)
第一种:for循环
第二种:增强for循环
public static void main(String[] args) {
//整型静态数组
int[] c = {1,2,3,4};
//遍历 for循环
for (int i = 0; i < c.length; i++) {
//i=0 1 2 3 通过索引访问
System.out.println(c[i]);
}
//增强for循环
/*
for(声明一个变量,用来接收每次从数组中取出来的元素 : 需要遍历的数组){
每循环一次,从数组中取出一个元素,赋给定义的变量,直到没有元素
}
*/
for(int t : c){
System.out.println(t);
}
}
运行结果:
for循环结果:
1
2
3
4
增强for循环结果:
1
2
3
4
//双精度型数组
double[] d = {1.0,2.0,3,4};
for (double t : d){
System.out.print(t+"\t");
}
//浮点型数组 浮点型数组它里面的小数数据后面必须加F或f 不然会报错
float[] f = {1.2f,2.3F,3.0f,4};
System.out.println(Arrays.toString(f));
运行结果:
1.0 2.0 3.0 4.0 [1.2, 2.3, 3.0, 4.0]
数组排序
冒泡排序
冒泡排序就是将相邻的元素比较交换,然后进行升序排序
import java.util.Arrays;
/**
* @author 辉欲静,而风止。
* 冒泡排序
* 典型的交换排序方法,需要按照升序进行排序
*/
public class BubbleSort {
/**
冒泡排序即就是相邻的元素进行比较排序
*/
public static void main(String[] args) {
int[] a = {5,4,3,2,1};
//控制循环次数 冒泡排序会将最大的一位放在最后,所以最后一位不用再比较
for (int i = 0; i < a.length-1; i++) {
//控制比较次数
for (int j = i+1; j < a.length; j++) {
if(a[i]>a[j]){
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
System.out.println(Arrays.toString(a));
/*
toString 方法:
public static String toString(int[] a) {
if (a == null)
return "null";
int iMax = a.length - 1;
if (iMax == -1)
return "[]";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) {
b.append(a[i]);
if (i == iMax)
return b.append(']').toString();
b.append(", ");
}
}
*/
}
}
选择排序
选择排序是一种简单直观的排序算法。它的工作原理是每一趟从待排序的数据元素中
选出最小(或最大)的一个元素,顺序放在已排好序的数列的最后,直到全部排序的
数据元素排完
选择排序算法通过选择和交换来实现排序,其排序流程如下:
(1)首先从原始数组中选择最小的一个数据,将其和第一个位置的数据交换
(2)接着从剩下的n-1个数据中选择次小的1个元素,将其和第二个位置的数据交换
(3)以此类推,直到最后两个数据完成交换。最后,便完成了对原始数据的从大到小的排序
import java.util.Arrays;
/**
* @author 辉欲静,而风止。
* 选择排序
* @date 2021年7月27日07:41:15
*/
public class Select {
public static void main(String[] args) {
Select w=new Select();
//调用选择排序1
System.out.println("普通选择排序:");
w.select1();
//调用优化后的选择排序2
System.out.println("优化选择排序:");
w.select2();
}
public void select1(){
int[] a={5,4,3,2,1};
//示例选择排序比较过程在笔记里
//从数组索引下标为零第一个元素开始
for (int i = 0; i < a.length-1; i++) {
//与后面的元素挨个比较
for (int j = i+1; j < a.length; j++) {
//从小到大排序 <从大到小排序
if(a[i]>a[j]){
//定义一个中间变量
int temp = a[i];
a[i]=a[j];
//交换位置
a[j]=temp;
}
}
System.out.println(Arrays.toString(a));
}
}
public void select2(){
int[] a = {5,4,3,2,1};
/*从第一个元素开始与后面每个元素比较*/
for (int i = 0; i < a.length-1; i++) {
//在外层循环下记录最小下标
int minIndex = i;
for (int j = i+1; j < a.length; j++) {
if(a[minIndex]>a[j]){
//再次记录最小下标
minIndex = j;
}
}
/*整个比较完成之后,交换位置*/
int temp = a[i];
a[i]=a[minIndex];
a[minIndex]=temp;
System.out.println(Arrays.toString(a));
}
// System.out.println(Arrays.toString(a));
}
}
运行结果:
普通选择排序:
[1, 5, 4, 3, 2]
[1, 2, 5, 4, 3]
[1, 2, 3, 5, 4]
[1, 2, 3, 4, 5]
优化选择排序:
[1, 4, 3, 2, 5]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
import java.util.Arrays;
/**
* @author 辉欲静,而风止。
* 选择排序
*/
public class Selects {
public static void main(String[] args) {
int[] a = {3,2,8,6,1};
for (int i = 0; i < a.length-1; i++) {
for (int j = i+1; j < a.length; j++) {
if(a[i]>a[j]){
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
//排序过程
System.out.println(Arrays.toString(a));
}
}
}
运行结果:
[1, 3, 8, 6, 2]
[1, 2, 8, 6, 3]
[1, 2, 3, 8, 6]
[1, 2, 3, 6, 8]
import java.util.Arrays;
/**
* @author 辉欲静,而风止。
* 优化选择排序
*/
public class SelectSort {
public static void main(String[] args) {
// int[] a = {2,0,3,4,9,1};
int[] a = {3,2,8,6,1};
for (int i = 0; i < a.length-1; i++) {
//记录最小下标
int minIndex = i;
for (int j = i+1; j < a.length; j++) {
if(a[minIndex]>a[j]){
//再次记录最小下标
minIndex = j;
}
}
int temp = a[i];
a[i] = a[minIndex];
a[minIndex] = temp;
System.out.println(Arrays.toString(a));
}
}
}
运行结果:
[1, 2, 8, 6, 3]
[1, 2, 8, 6, 3]
[1, 2, 3, 6, 8]
[1, 2, 3, 6, 8]
插入排序
有一个已经有序的数据序列,要求在这个已经排好的数据序列中插入一个数,但要求插入后此数据序列
仍然有序,这个时候就要用到一种新的排序方法——插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据,算法适用于少量数据的排序。
插入排序是将要排序的数组分为两个部分:一部分为有序,一部分无序,每次从无序部分中取出一个
元素与有序部分进行比较,若小于前面的元素,则交换位置,直到数组变为有序数组为止
import java.util.Arrays;
/**
* @author 辉欲静,而风止。
* 插入排序
*/
public class ChaRuSort {
public static void main(String[] args) {
int[] a = {9,5,1,0,7,2};
//外层循环取出除第一元素外的其他所有元素
for (int i = 1; i < a.length; i++) {
//确保存外层循环取出的元素都与前面每一个元素进行比较
//从后向前比较,比较到第0个位置停止
for (int j = i; j > 0; j--) {
if(a[j]<a[j-1]){
int temp = a[j];
a[j] = a[j-1];
a[j-1] = temp;
}
}
}
System.out.println(Arrays.toString(a));
}
}
import java.util.Arrays;
/**
* @author 辉欲静,而风止。
* 优化插入排序
*/
public class ChaRu {
public static void main(String[] args) {
int[] a = {9, 5, 1, 0, 7, 2};
//记录当前要排序的那个元素
int currentValue = 0;
for (int i = 0; i < a.length - 1; i++) {
//拿到无序数组首位元素5
currentValue = a[i + 1];
//记录当前所比较的位置
int preIndex = i;
while (preIndex >= 0 && currentValue < a[preIndex]) {
//若是后一个元素小于前面的元素,则将前面的元素依次向后移一位
a[preIndex + 1] = a[preIndex];
preIndex--;//-1 不满足循环条件 执行下面语句
}
//将小的元素插入到0号位置
//preIndex=-1 + 1 =0
a[preIndex + 1] = currentValue;
}
System.out.println(Arrays.toString(a));
}
}
二维数组
二维数组的定义
数组的数组————二维数组的每一个元素是一个一维数组。例如:
int [] [] a = {{1,2,3},{1,2,3},{1,2,3}};
二维数组的声明
int [] [] a;
int a[] [];
注意:建议使用第一种,不容易混淆数据类型
数组创建
int [][]a = new int[][]{{1,2,3},{1,2,3},{1,2,3}};
int [] [] b = {{1,2,3},{1,2,3},{1,2,3}};
int [] [] c = new int[3] [5];
● int[][] arr = new int[3] [5];——定义了一个整型的二维数组,这个二维数组包含3个一维数组,每一个一维数组包含5个元素
import java.util.Arrays;
/**
* @author 辉欲静,而风止。
* 二维数组
*/
public class TwoArray {
public static void main(String[] args) {
/*
二维数组的每个元素就是一个一维数组
声明方式 int[][] a;
int a[][]; 建议使用第一种,不容易混淆数据类型
*/
//二维数组中有三个长度为5的一维数组
int[][] a=new int[3][5];
//给定二维数组的长度和元素
int[][] b={{1,3,2},{3,5},{6,8}};
//输出二维数组b中索引下标为1的一维数组中索引为0的元素 3
System.out.println(b[1][0]);
}
}
二维数组的迭代
int[][] b={{1,3,2},{3,5},{6,8}};
//b[i]遍历二维数组中的元素一维数组
for (int i = 0; i < b.length; i++) {
System.out.println(Arrays.toString(b[i]));
}
for (int i = 0; i < b.length; i++) {
for (int j = 0; j < b[i].length; j++) {
System.out.print(b[i][j]+"\t");
}
System.out.print("\n");
}