回顾
1.适用情况：while:当 do...while:直到 for:固定次数
2.嵌套循环：越少越好 外层一次内层所有次 break只跳出一层循环
3.数组：
1>相同数据类型元素的集合
2>是一种数据类型（引用类型）
3>int[] arr = new int[]4; //0,0,0,0
4> int[] arr = {1, 4, 7};
int[] arr = new int[]{1, 4, 7};
5>System.out.println(arr.length);
下标从0开始，最大到arr.length-1
arr[0] = 100;
System.out.println(arr[arr.length-1]);
arr[4] = 100; //数组下标越界异常
for(int i=0; i<arr.length; i++){ //数组的遍历
System.out.println(arr[i]);
}
6>System.arrsycopy(a,1,a1,0,4);//把数组a的第2个元素开始复制到数组a1的a1[0]到a1[4]
int[] a1 = Arrays.copyOf(a,6);
a = Arrays.copyOf(a, a.length+1); //数组长度扩容
7>Arrays.sort(arr); //升序
冒泡排序原理：
4个数冒3轮
每轮都是从第1个开始冒，每一次都和它的下一个元素比
冒出来的都不带它玩了
质数：素数，只能被1和它本身整除的数
不是质数：只要有得0的
是质数：所有都不得0的
并非一次判断得到最终结果，-----开关
package day06;
//求2-100之间的质数
public class PrimeNumber {
public static void main(String[] args) {
int count = 0; //质数的个数---计数器
for(int num=2; num<=100; num++){
boolean flag = true;//1.假设是质数
for(int i=2; i<Math.sqrt(num); i++){
if(num%i==0){
flag = false; //2.改为不是质数
break;
}
}
if(flag){ //3.判断得出结论
count++;//质数的个数增1
System.out.print(num+"\t");
if(count%10==0){
System.out.println();
}
}
}
}
}正课
方法：函数/过程
用于封装一段特定的逻辑功能
方法尽可能的独立（一个方法只干一件事）
方法可以被反复的调用多次
避免代码的重复，便于代码的维护，有利于团队的协作开发
方法的定义
修饰词 返回值类型 方法名(参数列表){方法体}
方法可以有参也可以无参，但有参更灵活
方法可能有返回值也可以没有返回值
无返回值时，返回值类型写为void
有返回值时，返回值类型写为特定的数据类型
方法的调用
无返回值方法：
方法名(有参传参);
有返回值方法：
数据类型 变量 = 方法名(有参传参);
retuen：
returen 值; //1.结束方法的执行 2.返回一个值给调用方
return; //结束方法的执行（只能用在void方法中）
猜字符小游戏
注意：
对基本类型判断相等，用==
对引用类型判断相等，用str.equals("字符串")
String->引用类型
1.设计数据结构：数据----变量
1）char[] chs; //随机生成的字符数组
2）char[] input; //用户输入的字符数组
3）int[] result; //对比的结果
4）int score; //得分
int count; //猜错的次数
2.设计程序结构：方法
1）主方法
public static void main(String[] args) {}
2）随机生成字符数组
public static char[] generate(){
char[] chs = new char[5];
//给chs中的每一个元素赋值
return chs;
}
3) 对比：随机字符数组与用户输入的字符数组
public static int[] check(char[] chs, char[] input){
int[] result = new int[2];
//
return result;
}
3.设计算法：方法的实现
//随机生成字符数组
public static char[] generate(){
char[] chs = new char[5]; //随机字符数组
return chs;
}
//对比：随机字符数组与用户输入的字符数组
public static int[] check(char[] chs, char[] input){
int[] result = new int[2];
return result;
}任务：
完成猜字符小游戏
要求：
至少独立完成generate()和check()方法
每周一做---三个编程题必须掌握
package day06;
import java.util.Scanner;
public class Guessing {
//主方法
public static void main(String[] args) {
/*
//单元测试：单独测试代码的方法 测试check方法和generate方法
char[] c1 = {'A', 'B', 'C', 'D', 'E'};
char[] c2 = {'W', 'B', 'D', 'N', 'E'};
int[] result1 = check(c1, c2);
//输出result[0] 和 result[1]
System.out.println(result1[0]);
System.out.println(result1[1]);
char[] chs1= generate();
System.out.println(chs1);
*/
Scanner scan = new Scanner(System.in);
char[] chs = generate(); //获取随机字符数组
System.out.print(chs); //作弊
int count = 0; //猜错的次数
while(true){ //自造死循环
System.out.println("猜吧！");
String str = scan.next().toUpperCase(); //获取用户输入的字符串,并转换为大写字母
if(str.equals("EXIT")){
System.out.println("下次再来吧！");
break;
}
char[] input = str.toCharArray(); //将字符串转换成字符的数组
int[] result = check(chs, input); //对比：随机字符数组与用书输入的字符数组
if(result[0] == chs.length){ //猜对了
int score = 100* chs.length - 10*count; //一个字符100分，猜错一个扣10分
System.out.println("恭喜你，猜对了！得分为："+score);
break; //结束循环
}else{
count++; //猜错次数增1
System.out.println("字符对个数：" + result[1] + "，位置对个数：" + result[0]);
}
}
}
//随机生成字符数组
public static char[] generate(){
char[] chs = new char[5]; //随机字符数组
//leeers数组
char[] letters = {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
boolean[] flags = new boolean[letters.length];//开关数组，默认为false
for(int i=0; i<chs.length; i++){//遍历随机字符数组chs
int index; //随机下标
do{
index = (int)(Math.random()*letters.length); //生成随机下标(0~25之间）
}while(flags[index]==true); //若下标对应的开关为true时,表示已存过，则重新生成新的index
//当下标对应的开关为false时，表示未存过，条件为假，则循环结束
chs[i] = letters[index]; //基于index下标去letters中获取数据，并赋值给chs中的每一个元素
flags[index] = true; //修改index下标对应开关为true,表示已存过
}
return chs;
}
//对比：随机字符数组与用户输入的字符数组
public static int[] check(char[] chs, char[] input){
int[] result = new int[2];//假设对比结果result[0] 为位置对，result[1] 为字符对；
for(int i=0; i<chs.length; i++){//遍历随机生成的字符数组chs[]
for(int j=0; j<input.length; j++){
if(chs[i] == input[j]){
result[1]++; //字符对的个数增1
if(i==j){//位置对的前提为字符对
result[0]++;//位置对的个数增1
}
break; //与input字符匹配后，跳出内层循环
}
}
}
return result;
}
}
Switch 开关的用法 boolean flag = true;
给开关一个默认值
改变开关的状态
判断开关的状态得出结论
经典案例：求出101到1000之间的质数，每5个数换行，并统计质数的个数（逻辑思维很重要）
package exercisesAfterClass;
//switch开关的用法，这个无论如何也要熟练掌握一下
//练习题：求出101~1000之间的所有质数（素数），并且每5个数换行展示
public class PrimeNumber_SwitchDemo {
public static void main(String[] args) {
int count = 0; //质数计数器
for(int i=101; i<=1000; i++){
boolean flag = true; //1.开关switch,默认是质数true
for(int j=2; j<=Math.sqrt(i); j++){ //除了1和它本身，能被2到平方根之间的数整除，就不是质数
if(i%j==0){
flag = false; //2.修改switch开关的状态为false
break; //跳出内层循环，外层循环i++,内层重新判断
}
}
//内层循环结束以后，如果flag=true,i是质数
//计数器count+1,打印质数i,
//并且count%5==0时，换行
if(flag){ //flag在外层循环默认赋值为true,所有if判断条件中的(flag)等于是(flag==true)
count++;
System.out.print(i + "\t");
if(count%5==0){
System.out.println();
}
}
}
//在整个嵌套循环外面，打印101~1000之间质数的个数
System.out.println("\n\n101到1000之间的质数个数为：" + count + "个.");
}
}
arr = Arrays.copyOf(arr, arr.length+1); 数组扩容
System.arraycopy(arr, 0, arr1, 1, arr.length); 将数组arr的第一个下标元素开始复制到数组arr1中的，从arr1中的第二个下标位置开始复制
经典案例：找出数组中的最小值，并将它赋值给数组中的第一个元素
package exercisesAfterClass;
import java.util.Arrays;
//经典案例：找出数组中的最小值，并将它赋值给数组中的第一个元素
public class MinimumValueInArray {
public static void main(String[] args) {
//创建int[] num,长度为10，初始化数组元素并赋值
int [] num = new int[10];
for(int i=0; i<num.length; i++){
num[i] = (int)(Math.random() * 100);
System.out.print(num[i] + "\t");
}
//找出数组元素中的最小值
int min = num[0]; //假设第一个元素为最小值
for(int i=1; i<num.length; i++){ //min依次和num[i]比较
if(min > num[i]){
min = num[i];
}
}
System.out.println("\n\n最小值为：" + min);
//创建一个数组num1,长度为num.length+1;
//将数组num的元素依次复制到数组num1中的下标 [1...num1.length-1]
//在把min的值赋值给num1[0]
int[] num1 = new int[num.length+1];
System.arraycopy(num, 0, num1, 1, num1.length-1);
num1[0] = min; //将min的值赋值给num1[0]
for(int i=0; i<num1.length; i++){ //循环打印数组num1中的元素
System.out.print( num1[i] + "\t");
}
System.out.println();
//给数组num扩容，将num1的元素复制到num中
num = Arrays.copyOf(num, num.length+1); //num数组长度加1
System.out.println("num的数组长度为：" + num.length);
System.arraycopy(num1, 0, num, 0, num.length);//疑问？这个位置为什么填num.length-1时，最后一个下标位置是0呢？
for(int i=0; i<num.length; i++){ //循环打打印扩容之后的num数组元素值，最小值为num[0]
System.out.print(num[i] + "\t");
}
}
}
经典案例：猜字符游戏GuessTheCharacterGame -----掌握
package day06;
import java.util.Scanner;
//GuessTheCharacterGame猜字符游戏
public class GuessTheCharacterGame {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int level;
do{
System.out.println("请输入等级（5、7、9）？");
level = scan.nextInt();
}while(level!=5 && level!=7 && level!=9);
char[] chs = generate(level); //生成随机字符
System.out.println(chs); //打印出正确答案
int count = 0; //猜错的次数
while(true){ //自造死循环
System.out.println("猜吧！");
String str = scan.next().toUpperCase(); //接收用户输入的字符串，并转成大写字母
if(str.equals("EXIT")){
System.out.println("下次在玩吧！");
break;
}
char[] input = str.toCharArray(); //将用户输入的字符串str转换成char数组，并赋值给input
int[] result = check(chs, input); //检查位置对和字符对的结果，保存到result[0]和result[1]中
if(result[0] == chs.length){
int score = chs.length * 100 - count * 10;
System.out.println("恭喜你，答对了！得分为：" + score);
break;
}else{
count++; //猜错次数加1
System.out.println("答错了，重猜吧！位置对的个数为：" + result[0]
+ ",字符对的个数为：" + result[1] );
}
}
}
//随机生成字符数组
public static char[] generate(int level){
char[] chs = new char[level]; //随机字符数组chs
//letters数组
char[] letters = {'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
boolean[] flag = new boolean[letters.length]; //1.设立一个开关，默认为false
for(int i=0; i<chs.length; i++){//遍历随机字符数组chs
int index; //数组下标
do{
index = (int)(Math.random() * letters.length); //letters长度为26，则index取值为[0,25]
}while(flag[index] == true); //如果flag[index]==true,说明下标存在过，则重新生index
//若下标对应的开关为false,则条件为假，循环结束
chs[i] = letters[index]; //基于index下标从letters中获取数据，并赋值给chs中的每一个元素
flag[index] = true; //修改index对应的开关为true,表示已存过
}
return chs;
}
//对比：随机字符数组与用户输入的字符数组
public static int[] check(char[] chs, char[] input){
int[] result = new int[2];// 假设result[0] ->位置对；result[1] -> 字符对
//循环对比chs[i] 和input[0]----input[input.length-1]中的所有数一一对比
for(int i=0; i<chs.length; i++){ //外层循环一次，内层循环所有次
for(int j=0; j<input.length; j++){
if(chs[i] == input[j]){ //字符匹配上，result[1]++
result[1]++;
if(i == j){//如果i==j,说明下标位置一样，位置对 resutl[0]++
result[0]++;
}
break; //判断完后，跳出内层循环，继续比较数组chs下一个元素
}
}
}
return result;
}
}
文章转载自amazingweiwei，如果涉嫌侵权，请发送邮件至：contact@modb.pro进行举报，并提供相关证据，一经查实，墨天轮将立刻删除相关内容。
