//******************************156*********************************************************************//
//数组的引出
public class Array01 {
public static void main(String[] args) {
它们的体重分别是3kg,5kg,1kg,3.4kg,2kg,50kg 。
请问这六只鸡的总体重是多少?平均体重是多少?
思路分析
1. 定义六个变量 double , 求和 得到总体重
2. 平均体重 = 总体重 / 6
3. 分析传统实现的方式问题. 6->600->566
4. 引出新的技术 -> 使用数组来解决.
double hen1 = 3;
double hen2 = 5;
double hen3 = 1;
double hen4 = 3.4;
double hen5 = 2;
double hen6 = 50;
double totalWeight = hen1 + hen2 + hen3 + hen4 + hen5 + hen6;
double avgWeight = totalWeight / 6;
System.out.println("总体重=" + totalWeight + "平均体重=" + avgWeight);
//******************************157*********************************************************************//
比如，我们可以用数组来解决上一个问题 => 体验
定义一个数组
老韩解读
1. double[] 表示 是double类型的数组， 数组名 hens
2. {3, 5, 1, 3.4, 2, 50} 表示数组的值/元素,依次表示数组的
第几个元素
double[] hens = {3, 5, 1, 3.4, 2, 50, 7.8, 88.8,1.1,5.6,100};
遍历数组得到数组的所有元素的和， 使用for
老韩解读
1. 我们可以通过 hens[下标] 来访问数组的元素
下标是从 0 开始编号的比如第一个元素就是 hens[0]
第2个元素就是 hens[1]
, 依次类推
2. 通过for就可以循环的访问 数组的元素/值
3. 使用一个变量 totalWeight 将各个元素累积
老师提示： 可以通过 数组名.length 得到数组的大小/长度
System.out.println("数组的长度=" + hens.length);
double totalWeight = 0;
for( int i = 0; i < hens.length; i++) {
System.out.println("第" + (i+1) + "个元素的值=" + hens[i]);
totalWeight += hens[i];
}
System.out.println("总体重=" + totalWeight + "平均体重=" + (totalWeight / hens.length) );
}
}
//*****************************************************************************************************//
//**************************************158*************************************************************//
//*****************************************************************************************************//
import java.util.Scanner;
public class Array02 {
public static void main(String[] args) {
//演示 数据类型 数组名[]=new 数据类型[大小]
//循环输入5个成绩，保存到double数组,并输出
//步骤
//1. 创建一个 double 数组，大小 5
(1) 第一种动态分配方式
double scores[] = new double[5];
(2) 第2种动态分配方式， 先声明数组，再 new 分配空间
double scores[] ; //声明数组， 这时 scores 是 null。如果这时：scores.length--->报错！
scores = new double[5]; // 分配内存空间，可以存放数据
2. 循环输入
scores.length 表示数组的大小/长度
Scanner myScanner = new Scanner(System.in);
for( int i = 0; i < scores.length; i++) {
System.out.println("请输入第"+ (i+1) +"个元素的值");
scores[i] = myScanner.nextDouble();
}
输出，遍历数组
System.out.println("==数组的元素/值的情况如下:===");
for( int i = 0; i < scores.length; i++) {
System.out.println("第"+ (i+1) +"个元素的值=" + scores[i]);
}
}
}
//*****************************************************************************************************//
//*************************************160**************************************************************//
//*****************************************************************************************************//
double[] hens = {3, 5, 1, 3.4} ;
//当数组值已知情况下
相当于：
double []hens=new double[4] ;
细节：[4]表示：总共4个元素
hens[0]=3 ;
//未知情况下
hens[1]=5 ;
定义和赋值的时候，[x]含义不同！
hens[2]=1 ;
细节：[2]表示：第3个元素
hens[3]=3.4 ;
//*****************************************************************************************************//
//*****************************************161*********************************************************//
//*****************************************************************************************************//
public class ArrayDetail {
//编写一个main方法
public static void main(String[] args) {
1. 数组是多个相同类型数据的组合，实现对这些数据的统一管理
int[] arr1 = {1, 2, 3, 60,"hello"};//String ->int
错！
double[] arr2 = {1.1, 2.2, 3.3, 60.6, 100};//int ->double
对
2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用
String[] arr3 = {"北京","jack","milan"};
3. 数组创建后，如果没有赋值，有默认值
int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，
boolean false，String null
short[] arr4 = new short[3];
System.out.println("=====数组arr4=====");
for(int i = 0; i < arr4.length; i++) {
System.out.println(arr4[i]);
// 0 0 0
}
6. 数组下标必须在指定范围内使用，否则报：下标越界异常，比如
int [] arr=new int[5]; 则有效下标为 0-4
即数组的下标/索引 最小:0
最大:数组长度-1
int [] arr = new int[5];
System.out.println(arr[5]);//数组越界,错！！
}
}
//*****************************************************************************************************//
//*********************************162*****************************************************************//
//*****************************************************************************************************//
public class ArrayExercise01 {
//编写一个main方法
public static void main(String[] args) {
创建一个char类型的26个元素的数组，分别 放置'A'-'Z'。
使用for循环访问所有元素并打印出来。
提示：char类型数据运算 'A'+1 -> 'B'
思路分析
1. 定义一个 数组
char[] chars = new char[26]
2. 因为 'A' + 1 = 'B' 类推，所以老师使用for来赋值
3. 使用for循环访问所有元素
char[] chars = new char[26];
for( int i = 0; i < chars.length; i++) {//循环26次
chars[i] = (char)('A' + i); //'A' + i 是int , 需要强制转换
}
//也可以这么做：
int j=0 ;
char[] chars = new char[26];
for ( char i = 'A';
i <= 'Z'; i++ ) {//循环26次
chars[j] = i; //'A' + i 是int , 需要强制转换
j++;
}
//循环输出
System.out.println("===chars数组===");
for( int i = 0; i < chars.length; i++) {//循环26次
System.out.print(chars[i] + " ");
}
}
}
//*****************************************************************************************************//
//************************************163***********************************************************//
//*****************************************************************************************************//
public class ArrayExercise02 {
//编写一个main方法
public static void main(String[] args) {
请求出一个数组int[]的最大值 {4,-1,9, 10,23}，并得到对应的下标
老韩思路分析
1. 定义一个int数组 int[] arr = {4,-1,9, 10,23};
2. 假定 max = arr[0] 是最大值 , maxIndex=0;
3. 从下标 1 开始遍历arr， 如果max < 当前元素，说明max 不是真正的
最大值, 我们就 max=当前元素; maxIndex=当前元素下标
4. 当我们遍历这个数组arr后 , max就是真正的最大值，maxIndex最大值
对应的下标
int[] arr = {4,-1,9,10,23};
int max = arr[0];
//假定第一个元素就是最大值
int maxIndex = 0;
//下标
for(int i = 1; i < arr.length; i++) {//从下标 1 开始遍历arr
if(max < arr[i]) {
//大的话
max = arr[i]; //留下来，射程max
maxIndex = i; //索引也留下来
}
}
System.out.println("max=" + max + " maxIndex=" + maxIndex);
}
}
//*****************************************************************************************************//
//*************************************164**************************************************************//
//*****************************************************************************************************//
public class ArrayAssign {
public static void main(String[] args) {
基本数据类型赋值, 赋值方式为"值拷贝"
n2的变化，不会影响到n1的值 ---> n1 和 n2没有毛关系！
int n1 = 10;
int n2 = n1;
//n2 重新开辟新的空间，来存储n1，所以n1和n2没有任何关系！
n2 = 80;
System.out.println("n1=" + n1);//10
System.out.println("n2=" + n2);//80
数组在默认情况下是引用传递，“赋的值是地址”，赋值方式为“引用赋值”
是一个地址 , arr2变化会影响到 arr1
int[] arr1 = {1, 2, 3};
int[] arr2 = arr1;
arr2 --->arr1 换句话：arr2 是arr1的外号。都是同一个东西
arr2[0] = 10;
//等价于 arr1[0]=10;
//看看arr1的值
System.out.println("====arr1的元素====");
for(int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i]);//10, 2, 3
}
arr2 和 arr1 同一个东西！！！
System.out.println("====arr2的元素====");
for(int i = 0; i < arr2.length; i++) {
System.out.println(arr2[i]);//10, 2, 3
}
}
}
//********************************** 165***************************************************************//
细节：数组（非基本类型）--->存储在“堆”里面。 arr2 和 arr1 共享一个空间！！
//*****************************************************************************************************//
//*************************************************166*************************************************//
//*****************************************************************************************************//
public class ArrayCopy {
public static void main(String[] args) {
将 int[] arr1 = {10,20,30}; 拷贝到 arr2数组,
要求数据空间是独立的----->先创造空间，再把数据一个一个移过去！
int[] arr1 = {10,20,30};
int[] arr2 = new int[arr1.length]; //创建一个新的数组arr2,开辟新的数据空间 大小 arr1.length;
for(int i = 0; i < arr1.length; i++) {
//遍历 arr1 ，把每个元素拷贝到arr2对应的元素位置
arr2[i] = arr1[i];
}
arr2[0] = 100;
//老师修改 arr2， 不会对arr1有影响.
//输出arr1
System.out.println("====arr1的元素====");
for(int i = 0; i < arr1.length; i++) {
System.out.println(arr1[i]);//10,20,30
}
arr1 和 arr2 相互独立！！
System.out.println("====arr2的元素====");
for(int i = 0; i < arr2.length; i++) {
System.out.println(arr2[i]);//
}
}
}
//*****************************************************************************************************//
//******************************************167********************************************************//
//*****************************************************************************************************//
public class ArrayReverse {
public static void main(String[] args) {
int[] arr = {11, 22, 33, 44, 55, 66};
规律
左右对称交换
1. 把 arr[0] 和 arr[5] 进行交换 {66,22,33,44,55,11}
2. 把 arr[1] 和 arr[4] 进行交换 {66,55,33,44,22,11}
3. 把 arr[2] 和 arr[3] 进行交换 {66,55,44,33,22,11}
4. 一共要交换 3 次 = arr.length / 2
5. 每次交换时，对应的下标 是 arr[i] 和 arr[arr.length - 1 -i]
int temp = 0;
int len = arr.length; //计算数组的长度
for( int i = 0; i < len / 2; i++) {
temp = arr[len - 1 - i];
// 交换 arr[i] 和 arr[arr.length - 1 -i]
arr[len - 1 - i] = arr[i];
arr[i] = temp;
}
j 相当于 arr[len - 1 - i]
//两种方法都行！
int j=len-1;
for( int i = 0; i < len / 2; i++) {
temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
j--;
}
//输出
System.out.println("===翻转后数组===");
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");//66,55,44,33,22,11
}
}
}
//*****************************************************************************************************//
//******************************************168********************************************************//
//*****************************************************************************************************//
public class ArrayReverse02 {
public static void main(String[] args) {
int[] arr = {11, 22, 33, 44, 55, 66};
//使用逆序赋值方式
//老韩思路
//1. 先创建一个新的数组 arr2 ,大小 arr.length
//2. 逆序遍历 arr ,将 每个元素拷贝到 arr2的元素中(顺序拷贝)
//3. 建议增加一个循环变量 j -> 0 -> 5
int[] arr2 = new int[arr.length];
//逆序遍历 arr
for(int i = arr.length - 1, j = 0; i >= 0; i--, j++) {
//i从后面往前，j从前面往后
//arr 后面的，给 arr2 前面
arr2[j] = arr[i];
}
4. 当for循环结束，arr2就是一个逆序的数组 {66, 55, 44,33, 22, 11}
5. 让 arr 指向 arr2数据空间, 此时 arr原来的数据空间就没有变量引用
arr 原来的会被当做垃圾，销毁
arr = arr2;
//arr 指向新的逆序数组 ······核心！！ 就像指针一样
System.out.println("====arr的元素情况=====");
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
}
}
//*****************************************************************************************************//
//*****************************************************************************************************//
//*****************************************************************************************************//
public class ArrayAdd {
public static void main(String[] args) {
要求：实现动态的给数组添加元素效果，实现对数组扩容。ArrayAdd.java
1.原始数组使用静态分配 int[] arr = {1,2,3}
2.增加的元素4，直接放在数组的最后 arr = {1,2,3,4}
3.用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n
思路分析
1. 定义初始数组 int[] arr = {1,2,3}//下标0-2
2. 定义一个新的数组 int[] arrNew = new int[arr.length+1];
3. 遍历 arr 数组，依次将arr的元素拷贝到 arrNew数组
4. 将 4 赋给 arrNew[arrNew.length - 1] = 4;把4赋给arrNew最后一个元素
5. 让 arr 指向 arrNew ;
arr = arrNew; 那么 原来arr数组就被销毁
int[] arr = {1,2,3};
int[] arrNew = new int[arr.length + 1];
for(int i = 0; i < arr.length; i++) {
//遍历 arr 数组，依次将arr的元素拷贝到 arrNew数组
arrNew[i] = arr[i];
}
arrNew[arrNew.length - 1] = 4;
//把4赋给arrNew最后一个元素
arr = arrNew;
//让 arr 指向 arrNew
，之前的数组会销毁
System.out.println("====arr扩容后元素情况====");
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
}
}
//*****************************************************************************************************//
//*******************************************170*******************************************************//
//*****************************************************************************************************//
import java.util.Scanner;
public class ArrayAdd02 {
public static void main(String[] args) {
要求：实现动态的给数组添加元素效果，实现对数组扩容。ArrayAdd.java
1.原始数组使用静态分配 int[] arr = {1,2,3}
2.增加的元素4，直接放在数组的最后 arr = {1,2,3,4}
3.用户可以通过如下方法来决定是否继续添加，添加成功，是否继续？y/n
思路分析
1. 定义初始数组 int[] arr = {1,2,3}//下标0-2
2. 定义一个新的数组 int[] arrNew = new int[arr.length+1];
3. 遍历 arr 数组，依次将arr的元素拷贝到 arrNew数组
4. 将 4 赋给 arrNew[arrNew.length - 1] = 4;把4赋给arrNew最后一个元素
5. 让 arr 指向 arrNew ;
arr = arrNew; 那么 原来arr数组就被销毁
6. 创建一个 Scanner可以接受用户输入
7. 因为用户什么时候退出，不确定，老师使用 do-while + break来控制
Scanner myScanner = new Scanner(System.in);
int[] arr = {1,2,3};
//初始化数组
do {
int[] arrNew = new int[arr.length + 1];
for(int i = 0; i < arr.length; i++) {
//遍历 arr 数组，依次将arr的元素拷贝到 arrNew数组
arrNew[i] = arr[i];
}
System.out.println("请输入你要添加的元素");
int addNum = myScanner.nextInt();
arrNew[arrNew.length - 1] = addNum;
//把addNum赋给arrNew最后一个元素
arr = arrNew;
//让 arr 指向 arrNew,
System.out.println("====arr扩容后元素情况====");
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
System.out.println("是否继续添加 y/n");
//问用户是否继续
char key = myScanner.next().charAt(0);
if( key == 'n') { //如果输入n ,就结束
break;
//不是'n'，就继续加
}
}while(true);
System.out.println("你退出了添加...");
}
}
//*****************************************************************************************************//
//************************************一次性问扩容几个***********************************************************//
//*****************************************************************************************************//
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner myScanner = new Scanner(System.in);
System.out.println("原始数组：{1,2,3}");
System.out.println("您想扩容多少个数字呢？");
int kuo =myScanner.nextInt();
int[] yuan={1,2,3};
int []hou = new int[yuan.length+kuo];
System.out.println(hou.length);
for (int i=0;i< hou.length;i++){
if(i>2){
System.out.println("扩容的第"+i+ "个数字：");
int t =myScanner.nextInt();
hou[i]=t;
continue;
}
hou[i]=yuan[i];
}
yuan=hou;
for (int i = 0; i < yuan.length; i++) {
System.out.print(hou[i] + "\t");
}
}
}
//*****************************************************************************************************//
//****************************************171*********************************************************//
//*****************************************************************************************************//
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner myScanner = new Scanner(System.in);
System.out.println("原始数组：{1,2,3,4,5,6}");
System.out.println("您想删除多少个数字呢？");
int kuo =myScanner.nextInt();
int[] yuan={1,2,3,4,5,6};
int []hou = new int[yuan.length-kuo];
System.out.println("删除后的长度："+hou.length);
for (int i=0;i< hou.length;i++){
hou[i]=yuan[i];
}
yuan=hou;
//别忘了哈！！
for (int i = 0; i < yuan.length; i++) {
System.out.print(hou[i] + "\t");
}
}
}
//*****************************************************************************************************//
//*********************************************174*****************************************************//
//*****************************************************************************************************//
public class BubbleSort {
public static void main(String[] args) {
/*
数组 [24,69,80,57,13]
第1轮排序: 目标把最大数放在最后
第1次比较[24,69,80,57,13]
第2次比较[24,69,80,57,13]
第3次比较[24,69,57,80,13]
第4次比较[24,69,57,13,80]
*/
int[] arr = {24, 69, 80, 57, 13, };
int temp = 0; //用于辅助交换的变量
将多轮排序使用外层循环包括起来即可
4就是 arr.length - 1 = 5 - 1
for( int i = 0; i < arr.length - 1; i++) {//外层循环是4次
for( int j = 0; j < arr.length - 1 - i; j++) {//4次比较-3次-2次-1次
// j j+1 后面的大--->交换！也就是说：大的在前面--->升序！
if(arr[j] > arr[j + 1]) {
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
System.out.println("\n==第"+(i+1)+"轮==");
// 0+1轮
for(int j = 0; j < arr.length; j++) {
System.out.print(arr[j] + "\t");
}
}
//*****************************************************************************************************//
//*************************************175************************************************************//
//*****************************************************************************************************//
import java.util.Scanner;
public class SeqSearch {
//编写一个main方法
public static void main(String[] args) {
/*
有一个数列：白眉鹰王、金毛狮王、紫衫龙王、青翼蝠王猜数游戏：
从键盘中任意输入一个名称，判断数列中是否包含此名称【顺序查找】
要求: 如果找到了，就提示找到，并给出下标值
思路分析
1. 定义一个字符串数组
2. 接收用户输入, 遍历数组，逐一比较，如果有，则提示信息，并退出
*/
String[] names = {"白眉鹰王", "金毛狮王", "紫衫龙王", "青翼蝠王"};
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入名字");
String findName = myScanner.next();
//遍历数组，逐一比较，如果有，则提示信息，并退出
//这里老师给大家一个编程思想/技巧, 一个经典的方法
int index = -1;
//标记！！
for(int i = 0; i < names.length; i++) {
//比较 字符串比较 equals, 如果要找到名字就是当前元素
if(findName.equals(names[i])) {
System.out.println("恭喜你找到 " + findName);
System.out.println("下标为= " + i);
index = i;
//把i 保存到 index
break;
//退出
}
}
if(index == -1) { //没有找到
System.out.println("sorry ,没有找到 " + findName);
}
}
}
//*****************************************************************************************************//
//**********************************176****************************************************************//
//*****************************************************************************************************//
public class TwoDimensionalArray01 {
public static void main(String[] args) {
请用二维数组输出如下图形
0 0 0 0 0 0
0 0 1 0 0 0
0 2 0 3 0 0
0 0 0 0 0 0
//什么是二维数组：
//老韩解读
//1. 从定义形式上看 int[][]
//2. 可以这样理解，原来的一维数组的每个元素是一维数组, 就构成二维数组
int[][] arr = { {0, 0, 0, 0, 0, 0},
{0, 0, 1, 0, 0, 0},
{0,2,
0, 3, 0, 0},
{0, 0, 0, 0, 0, 0} };
关于二维数组的关键概念
(1)System.out.println("二维数组的元素个数=" + arr.length);
(2) 二维数组的每个元素是一维数组, 所以如果需要得到每个一维数组的值
还需要再次遍历
(3) 如果我们要访问第 (i+1)个一维数组的第j+1个值 arr[i][j];
举例 访问 3, 第3个一维数组的第4个值 arr[2][3]
System.out.println("第3个一维数组的第4个值=" + arr[2][3]); //3
//输出二维图形
for(int i = 0; i < arr.length; i++) {//遍历二维数组的每个元素
//遍历二维数组的每个元素(数组)
//老韩解读
//1. arr[i] 表示 二维数组的第i+1个元素 比如arr[0]：二维数组的第一个元素
//2. arr[i].length 得到 对应的 每个一维数组的长度
for(int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + " "); //输出了一维数组
}
System.out.println();//换行
}
}
}
//*****************************************************************************************************//
//*************************************177*************************************************************//
//*****************************************************************************************************//
public class TwoDimensionalArray02 {
public static void main(String[] args) {
int arr[][] = new int[2][3];
//同时声明，用
int arr[][]; //声明二维数组
arr = new int[2][3];//再开空间
0 0 0
0 0 0
arr[1][1] = 8;
0 0 0
0 8 0
for(int i = 0; i < arr.length; i++) {
for(int j = 0; j < arr[i].length; j++) {//对每个一维数组遍历
System.out.print(arr[i][j] +" ");
}
System.out.println();//换行
}
}
细节：二维数组 arr[][]--->0x0001
0x0001:0x0002 （二维存储地址）
}
0x0002:0 0 0
0x0003:0 1 0
0x0003
发现，本质：存储的是一维数组
//*****************************************************************************************************//
//************************************179**************************************************************//
//*****************************************************************************************************//
public class TwoDimensionalArray03 {
public static void main(String[] args) {
看一个需求：动态创建下面二维数组，并输出
i = 0: 1
i = 1: 2 2
i = 2: 3 3 3
一个有三个一维数组, 每个一维数组的元素是不一样的
int[][] arr = new int[3][];
//列数不确定
for(int i = 0; i < arr.length; i++) {//遍历arr每个一维数组
给每个一维数组开空间 new
·····如果没有给一维数组 new ,那么 arr[i]就是null！！！！！先开空间，再赋值！！
arr[i] = new int[i + 1];
//遍历一维数组，并给一维数组的每个元素赋值
for(int j = 0;
j < arr[i].length; j++) {
arr[i][j] = i + 1;//赋值
}
}
System.out.println("=====arr元素=====");
for(int i = 0; i < arr.length; i++) {
for(int j = 0; j < arr[i].length; j++) {
//输出arr的每个一维数组
System.out.print(arr[i][j] + " ");
}
System.out.println();//换行
}
}
}
//*****************************************************************************************************//
//***************************************180***********************************************************//
//*****************************************************************************************************//
public class TwoDimensionalArray04 {
public static void main(String[] args) {
int[][] arr = {{1,1,1}, {8,8,9}, {100}};
//对
int[][] arr = {{1,1,1}, {8,8,9}, 100};
//错！！100:int--x-->一维数组 不行！！
}
}
//*****************************************************************************************************//
//**************************************181************************************************************//
//*****************************************************************************************************//
public class TwoDimensionalArray05 {
public static void main(String[] args) {
int arr[][]={{4,6},{1,4,5,7},{-2}}; 遍历该二维数组，并得到和
1. 遍历二维数组，并将各个值累计到 int sum
int arr[][]= {{4,6},{1,4,5,7},{-2}};
int sum = 0;
for(int i = 0; i < arr.length; i++) {
for(int j = 0; j < arr[i].length; j++) {
//遍历每个一维数组
sum += arr[i][j];
}
}
System.out.println("sum=" + sum);
}
}
//*****************************************************************************************************//
//*******************************************182*******************************************************//
//*****************************************************************************************************//
public class YangHui {
public static void main(String[] args) {
使用二维数组打印一个 10 行杨辉三角
1
1 1
1 2 1
1 3 3
1
1 4 6
4
1
1 5 10 10 5 1
规律
1.第一行有 1 个元素, 第 n 行有 n 个元素
2. 每一行的第一个元素和最后一个元素都是 1
3. 从第三行开始, 对于非第一个元素和最后一个元素的元素的值. arr[i][j]
arr[i][j]
=
arr[i-1][j] （上）+ arr[i-1][j-1]（上左） ; //必须找到这个规律
int[][] yangHui = new int[12][];
for(int i = 0; i < yangHui.length; i++) {//遍历yangHui的每个元素
yangHui[i] = new int[i+1];
给每个一行，先开空间
for(int j = 0; j < yangHui[i].length; j++){
//给每个一维数组(行) 赋值
if(j == 0
j == yangHui[i].length - 1) {
//每一行的第一个元素和最后一个元素都是1
yangHui[i][j] = 1;
} else {
yangHui[i][j]
=
yangHui[i-1][j] + yangHui[i-1][j-1]; //中间的元素
}
}
}
//输出杨辉三角
for(int i = 0; i < yangHui.length; i++) {
for(int j = 0; j < yangHui[i].length; j++) {//遍历输出该行
System.out.print(yangHui[i][j] + "\t");
}
System.out.println();//换行.
}
}
}
//*****************************************************************************************************//
//***************************************184***********************************************************//
//*****************************************************************************************************//
int []x,y[] ;
//相当于： int []x ;
int [][]y;
x[0]=y;
// int=二维 错！
y[0]=x;
// 一维=一维 对！
y[0][0]=x;
//int=一维
错！
x[0][0]=y;
//x[0][0]错误！！
y[0][0]=x[0];
//int=int 对！！
x=y;
//一维=二维 错！
int []x,y ;
//相当于： int []x ;
int []y;
//*****************************************************************************************************//
//******************************************185********************************************************//
//*****************************************************************************************************//
String strs[]={'a','b','c'};
//char--x-->String 错！
String []strs={"a","b","c"};
//对！！
String []strs=new String {"a""b""c"};
//错！！不写逗号，那么别写 new String
String []strs=new String {"a","b","c"}; //对！！
String []strs=new String[] {"a","b","c"};
//对！可以加上[],但是不能写具体数字
String []strs=new String [3]{"a","b","c"}; //错！！[?]不能写数字。让系统自己判断！
String foo="blue";
boolean[]bar=new boolean[2];
// bar={ false,false } 默认：false
if (bar[0])
foo="green"
System.out.print(foo);
//*****************************************************************************************************//
//***************************************187***********************************************************//
//*****************************************************************************************************//
public class Homework04 {
public static void main(String[] args) {
已知有个升序的数组，要求插入一个元素，该数组顺序依然是升序, 比如:
[10， 12， 45， 90],
添加23 后, 数组为 [10， 12，23， 45， 90]
思路 本质数组扩容 + 定位
1. 我们先确定 添加数应该插入到哪个索引
2. 然后扩容
int[] arr = {10, 12, 45, 90};
//先定义原数组
int insertNum = 111;
int index = -1; //index就是要插入的位置
遍历 arr数组， 如果发现 insertNum<=arr[i], 说明 i 就是要插入的位置
使用 index 保留 index = i;
如果遍历完后，没有发现 insertNum<=arr[i]， 说明 index = arr.length
即：添加到arr的最后
for(int i = 0; i < arr.length; i++) {
if(insertNum <= arr[i]) {
index = i;
break; //找到位置后，就退出
}
}
//判断index 的值
if(index == -1) { //说明没有还没有找到位置，只能放在“最后”
index = arr.length;
}
····细节：当i == index时，j不变，i++，所以，原来的j指向下一个arr！！！核心在这儿
//扩容 arr.length + 1
//先创建一个新的数组，大小 arr.length + 1
int[] arrNew = new int[arr.length + 1];
//下面老师准备将arr的元素拷贝到 arrNew ,并且要跳过 index位置
//i 控制arrNew的下标
, j用来控制arr数组的下标
for(int i = 0, j = 0; i < arrNew.length; i++) {
if( i != index ) { //说明可以把 arr的元素拷贝到 arrNew
arrNew[i] = arr[j];
j++;
} else { //i这个位置就是要插入的数
arrNew[i] = insertNum;
}
}
arr = arrNew;
//让arr 指向 arrNew , 原来的数组，就成为垃圾，被销毁
System.out.println("======插入后，arr数组的元素情况======");
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
}
}
//*****************************************************************************************************//
//**************************************188************************************************************//
//*****************************************************************************************************//
public class Homework05 {
public static void main(String[] args) {
随机生成10个整数(1_100的范围)保存到数组，并倒序打印以及求平均值、求最大值和最大值的下标、
并查找里面是否有 8
Homework05.java
int[] arr = new int[10];
(int)(Math.random() * 100) + 1 ----> 生产 随机数 1-100
for(int i = 0; i < arr.length; i++) {
arr[i] = (int)(Math.random() * 100) + 1;
}
System.out.println("====arr的元素情况=====");
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
//10个随机数存储完毕！
System.out.println("\n====arr的元素情况(倒序)打印=====");
for(int i = arr.length -1; i >= 0; i--) {
System.out.print(arr[i] + "\t");
}
//平均值、求最大值和最大值的下标
double sum = arr[0];
int max = arr[0];
int maxIndex = 0;
for(int i = 1; i < arr.length; i++ ) {
sum += arr[i]; //累积和
if( max < arr[i]) {//说明max不是最大值，就变化
max = arr[i];
maxIndex = i;
}
}
System.out.println("\nmax=" + max + " maxIndex=" + maxIndex);
System.out.println("\n平均值=" + (sum / arr.length));
//查找数组中是否有8->使用顺序查找
int findNum = 8;
int index = -1; //如果找到，就把下标记录到 index
for(int i = 0; i < arr.length; i++) {
if(findNum == arr[i]) {
System.out.println("找到数" + findNum + " 下标=" + i);
index = i;
//标记，别忘了！！
break;
}
}
if(index == -1) {
System.out.println("没有找到数" + findNum );
}
}
}
//*****************************************************************************************************//
//*************************************189*************************************************************//
//*****************************************************************************************************//
//冒泡排序
//要求从小到大
int[] arr = {20, -1, 89, 2, 890, 7};
int temp = 0; //辅助交换
for(int i = 0; i < arr.length -1 ; i++) {//外层循环(轮)
for(int j = 0; j < arr.length - 1 - i; j++) {//每轮的比较次数
//如果是从小到大，条件是 arr[j] > arr[j+1]
//如果是从大到小，条件是 arr[j] < arr[j+1]
if(arr[j] > arr[j+1]) {
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
//搞定
System.out.println("\n==== 排序后====");
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
}
}