目录
数组初始化
（1）动态初始化1
- 数组的定义：数据类型 数组名[ ] = new 数据类型[ 大小 ] eg: int a[] = new int[5];
- 也可以写成：数据类型[ ] 数组名 = new 数据类型[ 大小 ]
- 数组的引用：数组名[下标/索引] 数组索引从0开始
import java.util.*;
public class Array01{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
//循环输入5个成绩，保存到double数组，并输出
double scores[] = new double[5];
for(int i = 0; i < scores.length; i++){
System.out.println("请输入第" + (i+1) + "个成绩：");
scores[i] = scanner.nextDouble();
}
System.out.println("=====================");
for(int i = 0; i < scores.length; i++){
System.out.println("第" + (i+1) + "个成绩：" + scores[i]);
}
}
}（2）动态初始化2
- 先声明数组，数据类型 数组名[ ]; 也可以写成：数据类型[ ] 数组名; eg: int a[];或int[] a;
- 再创建数组，数组名 = new 数据类型[大小]; eg: a = new int[10];
（3）静态初始化
数据类型 数组名[] = {元素值,元素值......};
eg: int a[] = {2,3,5,7,8};
数组细节
- 数组是多个相同类型数据的组合
- 数组中的元素可以是任何数据类型
- 数组创建后，如果没有赋值，有默认值int -> 0, short -> 0, byte -> 0, long -> 0, float -> 0.0, double -> 0.0, char -> \u0000, boolean false, String null
- 数组下标从0开始
- 数组下标必须在指定范围内使用，否则报：下标越界异常
- 数组属于引用类型，数组型数据是对象
- 数组长度：数组名.length;
小练习-试试将大写26字母存储到数组中~
import java.util.*;
public class ArrayExercise01{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
/*
创建一个char类型的26个元素的数组，存储A-Z
使用for循环访问所有元素并打印出来
*/
char letters[] = new char[26];
for(int i = 0; i < 26; i++){
letters[i] = (char)('A' + i); //注意'A'+i是int，需强制转换
}
for(int i = 0; i < letters.length; i++){
System.out.print(letters[i] + " ");
}
}
}练一练：求数组元素最大值
import java.util.*;
public class ArrayExercise02{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
//求数组元素最大值
int a[] = new int[100];
System.out.print("请输入数组长度：");
int n = scanner.nextInt();
System.out.print("请依次输入数组元素：");
for(int i = 0; i < n; i++){
a[i] = scanner.nextInt();
}
int maxIndex = 0;
for(int i = 1; i < n; i++){
if(a[i] > a[maxIndex]){
maxIndex = i;
}
}
System.out.print("数组最大值为：" + a[maxIndex]);
}
}数组赋值机制
- 基本数据类型赋值，赋值方式为值拷贝
- 引用数据类型赋值 ，赋的值是地址，赋值方式为引用赋值
数组翻转
import java.util.*;
public class ArrayReverse{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
//元素输入
int a[] = new int[100];
System.out.print("请输入数组长度：");
int n = scanner.nextInt();
System.out.print("请依次输入数组元素：");
for(int i = 0; i < n; i++){
a[i] = scanner.nextInt();
}
System.out.println("翻转前的数组：");
for(int i = 0; i < n; i++){
System.out.print(a[i] + "\t");
}
//数组翻转
for(int i = 0; i < n/2; i++){
int temp = a[i];
a[i] = a[n-i-1];
a[n-i-1] = temp;
}
System.out.println("\n翻转后的数组：");
for(int i = 0; i < n; i++){
System.out.print(a[i] + "\t");
}
}
}数组扩容
编程实现动态给数组添加元素，要求：
- 原始数组静态分配
- 增加的元素y/n直接放在数组最后
- 添加成功是否继续y/n
import java.util.*;
public class ArrayAdd{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
int arr[] = {1,2,3};
//数组扩容
char answer = ' ';
do{
int newArr[] = new int[arr.length+1];
for(int i = 0; i < arr.length; i++){
newArr[i] = arr[i];
}
System.out.println("请输入你要添加的元素：");
int t = scanner.nextInt();
newArr[newArr.length-1] = t;
arr = newArr;
System.out.println("还要继续添加吗？");
answer = scanner.next().charAt(0);
}while(answer!='n');
System.out.println("扩容后的数组：");
for(int i = 0; i < arr.length; i++){
System.out.print(arr[i] + "\t");
}
}
}数组缩减
编程实现动态的给数组缩减元素，提示用户是否继续缩减，每次缩减最后那个元素，只剩下最后一个元素时，提示不能缩减。
import java.util.*;
public class ArrayReduce {
public static void main(String []args) {
Scanner scanner = new Scanner(System.in);
int arr[] = {1, 2, 3, 4, 5};
char answer = ' ';
do{
int newArr[] = new int[arr.length - 1];
for(int i = 0; i < arr.length - 1; i++){
newArr[i] = arr[i];
}
arr = newArr;
System.out.println("缩减后的数组：");
for(int i = 0; i < arr.length; i++){
System.out.print(arr[i] + "\t");
}
System.out.println("\n还要继续缩减元素吗？y/n");
answer = scanner.next().charAt(0);
if(arr.length==1){
System.out.println("只剩一个元素，不能缩减了！");
break;
}
}while(answer != 'n');
}
}冒泡排序
- 对n个元素的数组进行冒泡排序
- 共进行（n-1）轮比较
- 每轮选出一个最大值，放到最后
import java.util.*;
public class BubbleSort{
public static void main(String []args) {
Scanner scanner = new Scanner(System.in);
int arr[] = {24,36,18,10,99,6};
//从小到大冒泡排序
for(int i = 0; i < arr.length-1; i++){
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 i = 0; i < arr.length; i++){
System.out.print(arr[i] + "\t");
}
}
}顺序查找
有一个数列：{白眉鹰王,金毛狮王,紫衫龙王,青翼蝠王}; 从键盘中任意输入一个名称，判断数列中是否包含此名称；若找到了就提示找到，并给出下标值
import java.util.*;
public class SeqSearch{
public static void main(String []args) {
Scanner scanner = new Scanner(System.in);
String names[] = {"白眉鹰王","金毛狮王","紫衫龙王","青翼蝠王"};
System.out.println("请输入名字：");
String findName = scanner.next();
boolean flag = false;
for(int i = 0; i < names.length; i++){
if(findName.equals(names[i])){
System.out.println("恭喜找到了，下标为：" + i);
flag = true;
break;
}
}
if(!flag){
System.out.println("sorry,没有找到~");
}
}
}二维数组
- 二维数组可以看成一维数组的每个元素是一个一维数组
- 二维数组的创建
- 二维数组的元素个数：arr.length是二维数组的行数，即一维数组的个数
- 二维数组每个元素的长度：arr[i].length对应每个一维数组的长度
eg:二维数组静态初始化
int[][] arr = {{0,0,0,0},{0,0,1,1},{2,1,0,9}} 二维数组动态初始化
- int arr[][] = new int[2][3];
- 先声明，再开空间：int arr[][]; arr = new int[2][3];
- 列数不确定的动态初始化，先声明，再遍历分别给每个元素开空间：int arr[][] = new int[3][];
eg:
创建如下二维数组：
{{1},
{2,2},
{3,3,3}}
import java.util.*;
public class TwoDimensionArray{
public static void main(String []args) {
Scanner scanner = new Scanner(System.in);
int arr[][] = new int[3][];
for(int i = 0; i < arr.length; i++){
arr[i] = new int[i+1];
for(int j = 0; j < arr[i].length; j++){
arr[i][j] = i+1;
}
}
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}
}
}杨辉三角
打印一个n行的杨辉三角，杨辉三角定义找小度 ~
下图为5行的杨辉三角
import java.util.*;
public class YangHui{
public static void main(String []args) {
Scanner scanner = new Scanner(System.in);
//杨辉三角形
System.out.println("请输入要打印的杨辉三角形行数：");
int n = scanner.nextInt();
int arr[][] = new int[n][];
for(int i = 0; i < arr.length; i++){
arr[i] = new int[i+1];
for(int j = 0; j < arr[i].length; j++){
if(j == 0 || j == i){
arr[i][j] = 1;
}else{
arr[i][j] = arr[i-1][j-1] + arr[i-1][j];
}
}
}
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}
}
}练习巩固
1.数组定义
answer: B, D
2.
answer: blue
解析：boolean数组未赋值，默认为false，见本文数组细节
3.
answer: 1 3 5 7
4.对有序数组插入元素后，要求依然有序（数组扩容+定位）
import java.util.*;
public class Homework01{
public static void main(String []args) {
Scanner scanner = new Scanner(System.in);
//对有序数组插入元素后，要求依然有序
int arr[] = {10, 12, 45, 90};
System.out.println("请输入要插入的数：");
int num = scanner.nextInt();
int newArr[] = new int[arr.length+1];
for(int i = 0; i < arr.length; i++){
if(num > arr[i]){
newArr[i] = arr[i];
}else{
newArr[i] = num;
newArr[i+1] = arr[i];
for(int j = i+1; j < arr.length; j++){
newArr[j+1] = arr[j];
}
break;
}
}
arr = newArr;
for(int i = 0; i < arr.length; i++){
System.out.print(arr[i] + "\t");
}
}
}5.
import java.util.*;
public class Homework02{
public static void main(String []args) {
Scanner scanner = new Scanner(System.in);
int arr[] = new int[10];
double sum = 0;
int maxIndex = 0;
int minIndex = 0;
boolean contain8 = false;
System.out.println("随机数组：");
for(int i = 0; i < arr.length; i++){
arr[i] = (int)(Math.random()*100) + 1;
System.out.print(arr[i] + " ");
sum += arr[i];
if(arr[i] == 8){
contain8 = true;
}
}
System.out.println("\n倒序打印：");
for(int i = arr.length-1; i >= 0; i--){
System.out.print(arr[i] + " ");
}
System.out.println();
System.out.println("平均数：" + sum/10);
for(int i = 1; i < arr.length; i++){
if(arr[maxIndex] < arr[i]){
maxIndex = i;
}
if(arr[minIndex] > arr[i]){
minIndex = i;
}
}
System.out.println("最大值：" + arr[maxIndex] + "，下标：" + maxIndex);
System.out.println("最小值：" + arr[minIndex] + "，下标：" + minIndex);
if(contain8){
System.out.println("随机数组包含了8");
}else{
System.out.println("随机数组不包含8");
}
}
}
扫一扫
3109
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
