1.2数组的声明概念：
1.数组中的数据又叫做元素
2.每个元素都有编号叫做下标/索引
3.下标从0开始
4.数组是引用数据类型
5.数组一旦初始化后，长度不可以改变（意味着数组不可以添加和删除）
6.数组存放元素的空间是连续的
1.21初始化数组的声明：数据类型[][] 数组名; => 例如 String[][] 字符串类型数组 int[][] 整型数组
1.22 静态初始化 vs 动态初始化数组的初始化：
1.静态初始化：数据由程序员指定，系统自动分配空间
2.动态初始化：长度由程序员指定，系统自动分配默认值
整数类型默认：0
浮点类型默认：0.0
字符类型默认：' '
布尔类型默认：false
引用类型默认：null-空
1.221 静态初始化一开始就知道数据，就使用静态初始化
一开始只知道长度，就使用动态初始化
package com.qf.test01;
public class Test01 {
public static void main(String[] args) {
//静态初始化1
//String[][] names = new String[][]{{"椎名空","水菜丽","北岛玲"},{"上原亚衣","北条麻衣","小峰由衣","波多野结衣"}};
//静态初始化2(先声明，再初始化)
//String[][] names;
//names = new String[][]{{"椎名空","水菜丽","北岛玲"},{"上原亚衣","北条麻衣","小峰由衣","波多野结衣"}};
//静态初始化3(简化静态初始化1)
String[][] names = {{"椎名空","水菜丽","北岛玲"},{"上原亚衣","北条麻衣","小峰由衣","波多野结衣"}};
//设置指定下标上的元素
names[0][2] = "李伟杰";
//获取指定下标上的元素
System.out.println("获取指定下标上的元素：" + names[0][2]);
//获取长度
System.out.println("获取二维数组中一维数组的长度：" + names.length);//2
System.out.println("获取二维数组中第一个一维数组元素的长度：" + names[0].length);//3
System.out.println("获取二维数组中第二个一维数组元素的长度：" + names[1].length);//4
System.out.println("------------");
//遍历数组 -- for循环
for (int i = 0; i < names.length; i++) {
for (int j = 0; j < names[i].length; j++) {
System.out.println(names[i][j]);
}
}
System.out.println("------------");
//遍历数组 -- foreach
for (String[] ss : names) {
for (String e : ss) {
System.out.println(e);
}
}
//总结遍历思路：先获取二维数组中的一维数组，再遍历一维数组中的元素
}
}
1.222动态初始化
package com.qf.test01;
public class Test02 {
public static void main(String[] args) {
//动态初始化1
//String[][] names = new String[2][3];//创建二维数组，其中包含2个一维数组，每个一维数组包含3个元素
//动态初始化2(先声明，再初始化)
String[][] names;
names = new String[2][3];
//设置指定下标上的元素
names[0][0] = "李伟杰1";
names[0][1] = "李伟杰2";
names[0][2] = "李伟杰3";
names[1][0] = "李伟杰4";
names[1][1] = "李伟杰5";
names[1][2] = "李伟杰6";
//获取指定下标上的元素
System.out.println("获取指定下标上的元素：" + names[0][2]);
//获取长度
System.out.println("获取二维数组中一维数组的长度：" + names.length);//2
System.out.println("获取二维数组中第一个一维数组元素的长度：" + names[0].length);//3
System.out.println("获取二维数组中第二个一维数组元素的长度：" + names[1].length);//4
System.out.println("------------");
//遍历数组 -- for循环
for (int i = 0; i < names.length; i++) {
for (int j = 0; j < names[i].length; j++) {
System.out.println(names[i][j]);
}
}
System.out.println("------------");
//遍历数组 -- foreach
for (String[] ss : names) {
for (String e : ss) {
System.out.println(e);
}
}
//总结遍历思路：先获取二维数组中的一维数组，再遍历一维数组中的元素
}
}
1.3深入二维数组的动态初始化
package com.qf.test01;
public class Test03 {
public static void main(String[] args) {
String[][] names = new String[2][];
String[] n1 = new String[3];
String[] n2 = new String[4];
names[0] = n1;
names[1] = n2;
}
}
1.4需求
1.定义一个函数，获取某个数组中的最小值
package com.qf.work;
public class Work01 {
public static void main(String[] args) {
int[] is = {64,12,81,8,45,27};
int min = getMin(is);
System.out.println("最小值为：" + min);
}
public static int getMin(int[] is) {
int min = is[0];
for (int i = 1; i < is.length; i++) {
if(min > is[i]){
min = is[i];
}
}
return min;
}
}
2.定义一个数组,数组成员10个,找出数组中最大数连同下标一起输出
package com.qf.work;
public class Work02 {
public static void main(String[] args) {
int[] is = {64,12,81,8,45,27,3,16,22,49};
int max = is[0];
int index = 0;
for (int i = 1; i < is.length; i++) {
if(max < is[i]){
max = is[i];
index = i;
}
}
System.out.println("最大值为：" + max);
System.out.println("最大值的下标为：" + index);
}
}
3.给定一个整型数组，数组成员10个,求该数组中第二大的数的下标
package com.qf.work;
import java.util.Arrays;
public class Work03 {
public static void main(String[] args) {
int[] is = {64,12,81,8,45,27,3,16,22,49};
//拷贝数组
int[] copyOf = Arrays.copyOf(is, is.length);
//排序
Arrays.sort(copyOf);
//第二大的数字
int num = copyOf[copyOf.length-2];
//遍历原数组，找出第二大的数字的下标
int index = 0;
for (int i = 0; i < is.length; i++) {
if(num == is[i]){
index = i;
break;
}
}
System.out.println("第二大的数字为：" + num);
System.out.println("第二大的数字的下标为：" + index);
}
}
4.B哥去参加青年歌手大奖赛,有10个评委打分,(去掉一个最高一个最低)求平均分?
package com.qf.work;
import java.util.Arrays;
public class Work04 {
public static void main(String[] args) {
int[] is = {64,12,81,8,45,27,3,16,22,49};
Arrays.sort(is);
int sum = 0;
for (int i = 1; i < is.length-1; i++) {
sum += is[i];
}
double avg = sum/8.0;
System.out.println("平均分为：" + avg);
}
}
5.利用冒泡排序对数据进行降序排序
package com.qf.work;
public class Work05 {
public static void main(String[] args) {
int[] is = {64,12,81,8,45,27,3,16,22,49};
for (int i = 0; i < is.length-1; i++) {
for (int j = 0; j < is.length-1-i; j++) {
if(is[j] < is[j+1]){
int temp = is[j];
is[j] = is[j+1];
is[j+1] = temp;
}
}
}
for (int num : is) {
System.out.println(num);
}
}
}
6.定义数组，存放5个学生的成绩【成绩值自己设定】，将成绩从大到小排序，获得成绩之和，平均成绩，最小成绩，最大成绩。
package com.qf.work;
public class Work06 {
public static void main(String[] args) {
int[] is = {64,12,81,8,45};
//成绩从大到小排序
for (int i = 0; i < is.length-1; i++) {
for (int j = 0; j < is.length-1-i; j++) {
if(is[j] < is[j+1]){
int temp = is[j];
is[j] = is[j+1];
is[j+1] = temp;
}
}
}
//最小成绩，最大成绩
int min = is[is.length-1];
int max = is[0];
//获得成绩之和
int sum = 0;
for (int i = 0; i < is.length; i++) {
sum += is[i];
}
//计算平均分
double avg = sum/5.0;
System.out.println("最大值：" + max);
System.out.println("最小值：" + min);
System.out.println("成绩之和：" + sum);
System.out.println("成绩平均分：" + avg);
}
}
7.定义一个长度为10的int数组,统计数组中的最大值、最小值、以及奇数和偶数的个数
package com.qf.work;
public class Work07 {
public static void main(String[] args) {
int[] is = {64,12,81,8,45,27,3,16,22,49};
int max = is[0];
int min = is[0];
int odd = 0;//奇数个数
int even = 0;//偶数个数
for (int i = 0; i < is.length; i++) {
if(max < is[i]){
max = is[i];
}
if(min > is[i]){
min = is[i];
}
if(is[i] % 2 == 0){
even++;
}
if(is[i] % 2 != 0){
odd++;
}
}
System.out.println("最大值：" + max);
System.out.println("最小值：" + min);
System.out.println("奇数个数：" + odd);
System.out.println("偶数个数：" + even);
}
}
8.提取一个方法，将指定数组中的数组元素进行反转
例如：{10,23,2,45,6}--->{6,45,2,23,10}
package com.qf.work;
public class Work08 {
public static void main(String[] args) {
int[] is = {10,23,2,45,6};
int[] newIs = method(is);
for (int num : newIs) {
System.out.println(num);
}
}
public static int[] method(int[] is) {
int[] newIs = new int[is.length];
int index = newIs.length-1;//设置index为新数组的最后一个下标
for (int num : is) {
newIs[index] = num;
index--;
}
return newIs;
}
}
9.将一个数组逆序输出
package com.qf.work;
public class Work09 {
public static void main(String[] args) {
int[] is = {10,23,2,45,6};
for (int i = is.length-1; i >= 0; i--) {
System.out.println(is[i]);
}
}
}
10.输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组
package com.qf.work;
import java.util.Arrays;
public class Work10 {
public static void main(String[] args) {
int[] is = {2,10,45,23,6};
int max = is[0];
int maxIndex = 0;
for (int i = 1; i < is.length; i++) {
if(max < is[i]){
max = is[i];
maxIndex = i;
}
}
//最大的与第一个元素交换
int temp1 = is[0];
is[0] = is[maxIndex];
is[maxIndex] = temp1;
int min = is[0];
int minIndex = 0;
for (int i = 1; i < is.length; i++) {
if(min > is[i]){
min = is[i];
minIndex = i;
}
}
//最小的与最后一个元素交换
int temp2 = is[is.length-1];
is[is.length-1] = is[minIndex];
is[minIndex] = temp2;
//输出
System.out.println(Arrays.toString(is));
}
}
1.5五子棋
package com.qf.test01;
import java.util.Scanner;
public class Test01 {
public static void main(String[] args) {
//棋盘长度
int len = 20;
//棋盘容器
String[][] goBang = new String[len][len];
//棋盘符号
String add = "╋";
String[] nums = {"⒈","⒉","⒊","⒋","⒌","⒍","⒎","⒏","⒐","⒑","⒒","⒓","⒔","⒕","⒖","⒗","⒘","⒙","⒚","⒛"}; //坐标
String black = "■"; //黑棋
String white = "○"; //白棋
//初始化数据
for (int i = 0; i < goBang.length; i++) {
for (int j = 0; j < goBang[i].length; j++) {
if(j == len-1){//每行的最后一列
goBang[i][j] = nums[i];
}else if(i == len-1){//最后一行
goBang[i][j] = nums[j];
}else{
goBang[i][j] = add;
}
}
}
//打印数组
for (String[] ss : goBang) {
for (String str : ss) {
System.out.print(str);
}
System.out.println();
}
Scanner scan = new Scanner(System.in);
boolean bool = true;//true-黑子 false-白子
while(true){
//输入坐标
System.out.println("请" + ((bool)?"黑":"白") + "子输入坐标：");
int x = scan.nextInt()-1;
int y = scan.nextInt()-1;
//判断坐标是否在棋盘范围内
if(x < 0 || x > len-2 || y < 0 || y > len-2){
System.out.println("坐标不在棋盘范围内，请重新输入...");
continue;
}
//判断坐标上是否有棋子
if(!goBang[x][y].equals(add)){
System.out.println("坐标上有棋子，请重新输入...");
continue;
}
//落子
goBang[x][y] = (bool)?black:white;
//置反
bool = !bool;
//打印数组
for (String[] ss : goBang) {
for (String str : ss) {
System.out.print(str);
}
System.out.println();
}
}
}
}
二、面向对象
2.1面向对象理解图
2.2创建类
package com.qf.test03;
//人类
public class Person {
//属性/全局变量
//属性的分类：静态属性、成员属性
//成员属性
String name;
char sex;
int age;
//方法
//方法的分类：构造方法、静态方法、成员方法、抽象方法
//成员方法
public void eat(){
System.out.println(this.name + "吃饭饭");
}
public void sleep(){
System.out.println(this.name + "睡觉觉");
}
public static void method(){
System.out.println("Person类的静态方法");
}
}
2.3调用类
package com.qf.test03;
//测试类
//作用：测试我们写好的代码
//特征：有主方法
public class Test01 {
public static void main(String[] args) {
//创建人类对象
Person p1 = new Person();
Person p2 = new Person();
//设置成员变量
p1.name = "罗菌鱼";
p2.name = "波多野结衣";
//调用成员方法
p1.eat();
p2.eat();
p1.sleep();
p2.sleep();
//静态方法使用类名调用
Person.method();
}
}
