Java第五课
Javase第五课
- Javase第五课
- 1.1 回顾
- 1.1.1 Java循环结构：
- 1.1.2 程序的调试 :
- 1.1.3 数组:
- 1.1.4 作业讲解：
- 1.2 数组&常见算法问题:
- 1.2.1 和和平均值(累加，总和除以个数)
- 1.2.2 最值(最大值 最小值)
- 1.2.3 查找
- 1.2.4 插入算法
- 1.2.5 排序算法:
- 1.2.6 参考代码：
- 1.3 二维数组:
- 1.3.1 定义和赋值:
- 1.3.2 案例:杨辉三角
- 1.3.3 课堂练习:
- 1.4 课堂综合练习:
- 1.5 总结:.
- 1.6 作业：
- 1.1 回顾
1.1 回顾
1.1.1 Java循环结构：
基本四种结构：
For /while/do-while /foreach
package test;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
System.out.println("******拼接之后输出数组元素********");
String str[] = { "abc", "xyz" };
/*
* for (String s : str) { s = s + "xx"; //拼接的结果只是s指向的结果而已，并不会改变数组元素
* System.out.println(s);// abcxx xyzxx }
*/
for (int i = 0; i < str.length; i++) {
str[i] = str[i] + "xx"; // 拼接的结果只是s指向的结果而已，并不会改变数组元素
System.out.println(str[i]);// abcxx xyzxx
}
System.out.println("******再次输出数组元素********");
for (String s : str) {
System.out.println(s);// abcxx xyzxx
}
}
}
String str [] = {“abc”,”xyz”};
for(String s : str)
{
s=s+”xx”;
Sysout(s);// abcxx xyzxx
}1.1.2 程序的调试 :
Step Over(F6) :但不执行，但是不会进入调用的某个方法的内部
Step into(F5) :单步执行，但是进入调用的那个方法的内部
Retun (F7) :和F5对应，从某个已经进入方法中跳出来
Resume(F8) :从当前断点，跳到下一个断点。
1.1.3 数组:
一组类型相同的数据的集合; 在内存中一段连续的空间，避免我们定义多个变量
定义: 数据类型 数组名[] = new 类型[长度];
定义: 数据类型 数组名[] = new 类型[]{值列表};
定义: 数据类型 数组名[] ={值列表};数组的访问: 下标 0 –数组.length-1结束;
使用数组通常和循环搭配使用;
1.1.4 作业讲解：
1) 从控制台接收5个学生的java成绩，求最高分和最低分;
package test;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
int weight[] = new int[5]; // 5 =>0
// 定义一个循环去接收用户输入的值
Scanner input = new Scanner(System.in);
// 使用max和剩下的每一个元素都要比较一下
for (int i = 0; i < weight.length; i++) {
System.out.println("请输入第" + (i + 1) + "个值");
weight[i] = input.nextInt();
}
// 假设数组中的第一个元素是最大值(这个数组元素一定是数组中真实的数据值，而不是默认值)
int max = weight[0];
int min = weight[0];
for (int i = 1; i < weight.length; i++) {
// 如果数组中的其他元素比 max还大的话，那么就将这个数组元素赋值给max
// 如果是最小值的话，这里的> 变成 <
if (weight[i] > max) {
max = weight[i];
}
if (weight[i] < min) {
min = weight[i];
}
}
input.close();
System.out.println("max :" + max + ",min :" + min);
}
}
2) 把十元钱人民币换成零钱（一元、二元、五元），有多少种兑换方法？
package test;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
// 如果都用来换1元 0~10
for (int i = 0; i <= 10; i++) {
// 2元 0~5
for (int j = 0; j <= 5; j++) {
// 5 0 ~2
for (int k = 0; k <= 2; k++) {
if (i + j * 2 + k * 5 == 10) {
System.out.println("1元: " + i + ",2元: " + j + ",5元:" + k);
}
}
}
}
}
}
1元: 0,2元: 0,5元:2
1元: 0,2元: 5,5元:0
1元: 1,2元: 2,5元:1
1元: 2,2元: 4,5元:0
1元: 3,2元: 1,5元:1
1元: 4,2元: 3,5元:0
1元: 5,2元: 0,5元:1
1元: 6,2元: 2,5元:0
1元: 8,2元: 1,5元:0
1元: 10,2元: 0,5元:0
3) 题目：求100之内的素数
素数: 只（找除了1和他本身以外的其他数字去运算,如果都不能整除，这个数字才是质数）能被1和他本身整除的数字,称为素数(质数)；101=》101%2看是不是能整除,不能整除,继续除以3 =>如果能整除，直接判定这个数字不是质数.
》101%3看是不是能整除,不能整除,继续除以4 =>如果能整除，直接判定这个数字不是质数.
》101%4看是不是能整除,不能整除,继续除以5 =>如果能整除，直接判定这个数字不是质数.
….
》101%平方根 看是不是能整除,不能整除,直接是质数，否则不是质数;
package test;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
/*
* int n; System.out.println("请输入一个整数 >2"); Scanner input = new
* Scanner(System.in);
*
* n = input.nextInt();
*
* input.close();
*/
for (int n = 3; n <= 100; n++) {
boolean flag = true;// 默认情况先是质数
// 循环开始
for (int i = 2; i <= Math.sqrt(n); i++) {
if (n % i == 0) {
// 不是质数
flag = false;
break;
}
}
if (flag)
System.out.print(n+" ");
//System.out.println(n + "是质数");
//else
//System.out.println(n + "不是质数");
}
}
}
1.2 数组&常见算法问题:
1.2.1 和和平均值(累加，总和除以个数)
见昨天的笔记内容
1.2.2 最值(最大值 最小值)
叶辉:70KG 思奇:65kg 灯辉:53kg 嘉颖: 61kg ;
假设第一个元素的值为最大，然后接下来用相邻的值和第一个值比较，保留大的那个值;再用这个值和下一个相邻的元素比较，保留最大的;以此类推 ;直到最后一个元素，得到了所有数字中的最大值;
package test;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
int weight[] = { 70, 65, 53, 56, 61, 80 };
// 假设数组中的第一个元素师最大值
int max = weight[0];
// 使用max和剩下的每一个元素都要比较一下
for (int i = 1; i < weight.length; i++) {
// 如果数组中的其他元素比 max还大的话，那么就将这个数组元素赋值给max
// 如果是最小值的话，这里的> 变成 <
if (weight[i] > max) {
max = weight[i];
}
}
System.out.println("max :" + max);
}
}
1.2.3 查找
package test;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
String[] names = { "小白", "小红", "小兰", "小黑", "小绿", "小白" };
// 查询 数组中是否包含特定的某个元素，比如是否包含 "小白"(2) ，要给出提示，如果存在，位置，如果不存在，就提示不存在
// 依次遍历数组元素，如果发现这个元素和要查找的元素相等，记录位置并输出
String find = "啊黄";
boolean flag = false;// 表示的是 是否找到 false没有找到
for (int i = 0; i < names.length; i++) {
if (names[i].equals(find)) {
// 有找到了
System.out.println("在第" + (i + 1) + "个位置找到了" + find);
// break 只要查找到了这个元素，就结束循环
flag = true;// 找到了
}
}
if (!flag) {
System.out.println("没有找到" + find);
}
}
}
1.2.4 插入算法
在一个已经按照特定顺序排好的数组中，我们要插入一个新的元素进来，要求，插入新的元素之后，数组元素依然是有序的.
package test;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
// 数组中的元素是有序的,此时长度是5,折中处理一下，后面要将一个新的元素存储在数组中, 最后一个位置0表示的是一个空位,
int array[] = { 1, 3, 5, 7, 9, 0 };
// 插入一个新的元素
System.out.println("请输入一个要插入的元素");
Scanner input = new Scanner(System.in);
int insert = input.nextInt();
// 如果用户输入的值 0 2 10
// 插入的动作 要找到自己的合适位置
int position = 5; // 数组中第6个元素的位置
// 查找,array.length 其实6,但是最后一个位置空位置
for (int i = 0; i < array.length - 1; i++) {
// 判断第一个出现比insert大的那个元素
if (array[i] > insert) {
// 记录i的值 然后从循环中 跳出来
position = i;
break;
}
}
System.out.println("position: " + position);
// 其他的元素要腾出位置给插入的那个元素
// 6 -2
for (int i = array.length - 2; i >= position; i--) {
// 移动位置
// System.out.println(array[i + 1] + "," + array[i]);
array[i + 1] = array[i];
}
// 将这个元素直接放在postion(下标)位置
array[position] = insert;
// 插入算法之后的输出
System.out.println("***********插入算法之后的输出*************");
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
1.2.5 排序算法:
12 7 -1 8 99
希望以上一组数能够按照一定的顺序(从大到小/从小到大)重新排列; 相邻的两个元素依次比较，根据比较条件，来交换位置;
第一轮开始: 比较了几(4)次; 结果是得到了5个数字中的最大值; :12和7比较，用>比较的话，如果条件为真，则交换两个元素
7 12 -1 8 99
继续比较 12和下一个相邻元素 12> -1 如果条件为真，则交换两个元素
7 -1 12 8 99
继续比较 12和下一个相邻元素 12> 8 如果条件为真，则交换两个元素
7 -1 8 12 99
继续比较 12和下一个相邻元素 12> 99如果条件为真，则交换两个元素,为假，什么都不做
7 -1 8 12 99(最大值
上面的代码的得到了数组中的最大值: 99 ,在数组的最后一个位置
第二轮开始: 比较了几(3)次; 结果是得到了剩余4个数字中的最大值;
原始数据:
7 -1 8 12
下一轮：重复上面的动作: 7>-1 真，交换位置
-1 7 8 12重复上面的动作: 7>8假，什么都不做
-1 7 8 12重复上面的动作: 8>12假，什么都不做
-1 7 8 12(最大值)继续下一轮：
…
第三轮开始: 比较了几(2)次; 结果是得到了剩余3个数字中的最大值; 第四轮开始: 比较了几(1)次;
结果是得到了剩余2个数字中的最大值;小结:5个数字，比较了4轮; 每一轮内部比较了几次? 4 3 2 1 满足条件的时候我们做什么?交换两个相邻的元素:
1.2.6 参考代码：
冒泡排序: 嵌套循环; 外控制比较的轮数(长度-1) ;内循环控制的是每轮比较的次数(长度-i-1) ; i是外循环变量; 内循环中比较相邻的元素( 使用内循环变量作为下标 array[j]>array[j+1]) ;结果 应该是从小到大;
package test;
import java.util.Scanner;
/**
* 小结:5个数字，比较了4轮; 每一轮内部比较了几次? 4 3 2 1 满足条件的时候我们做什么?交换两个相邻的元素:
*
* @author Administrator
*
*/
public class Test {
public static void main(String[] args) {
// 定义数组并赋值
int array[] = { -1, 99, 66, 7, -90 };
// 比较几轮?
// 定义一个循环来表示比较的轮数 4轮-> 数组长度-1
for (int i = 0; i < array.length - 1; i++) {
// 每一轮比较了几次?
for (int j = 0; j < array.length - i - 1; j++) {
// 比较
if (array[j] > array[j + 1]) {
// 交换
int t = array[j];
array[j] = array[j + 1];
array[j + 1] = t;
}
}
}
System.out.println("冒泡排序结束后的结果");
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
1.3 二维数组:
二维数组，在内存中的结构和一维数组是一致的;但是我们可以将其理解为一个平面结构;
1.3.1 定义和赋值:
数组元素类型[ ][ ] 变量名称=new 数组元素类型[一维长度] [二维长度];
1.3.2 案例:杨辉三角
| 1 | ||||
|---|---|---|---|---|
| 1 | 1 | |||
| 1 | 2 | 1 | ||
| 1 | 3 | 3 | 1 | |
| 1 | 4 | 6 | 4 |
package test;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
int[][] array = new int[5][5];
// 只得到第一个维度的长度
// System.out.println(array.length);
for (int i = 0; i < 5; i++) {
for (int j = 0; j <= i; j++) {
// 第一列 行和列相等
if (j == 0 || i == j) {
array[i][j] = 1;
} else {
array[i][j] = array[i - 1][j - 1] + array[i - 1][j];
}
// 打印数组中的这个元素
System.out.print(array[i][j] + " ");
}
System.out.println();
}
}
}
1.3.3 课堂练习:
定义二维数组，统计班级5个学生的Java,C#,Python课程的成绩，并求每门课程的平均分;
数组定义: double score[][] = new double[3][5];
package test;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
double score[][] = new double[3][5];
Scanner input = new Scanner(System.in);
// 三门成绩
for (int i = 0; i < 3; i++) {
// 求和
double sum = 0;
System.out.println("请输入第" + (i + 1) + "门成绩");
// 5个学生java成绩,C#成绩，python成绩
for (int j = 0; j < 5; j++) {
System.out.println("请输入第" + (j + 1) + "个学生的成绩");
score[i][j] = input.nextDouble();
sum += score[i][j];
}
System.out.println("第" + (i + 1) + "门平均成绩" + sum / 5);
}
}
}
1.4 课堂综合练习:
简单的控制台小程序:
1. 用户登录: 用户名和密码的输入，根据用户名和密码来判断 ;登录成功
2. 用户菜单选项:最大值/最小值/排序/抽奖/退出
3. 当某个功能结束之后，我们再自动回到用户菜单选项
package test;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
denglu();
}
/**
* 登录的方法
*/
public static void denglu() {
// TODO Auto-generated method stub
System.out.println("请输入用户名 密码...");
String username = "admin";
if ("admin".equals(username)) {
System.out.println("登陆成功");
// 去菜单页面
caidan();
} else {
System.out.println("登陆失败");
}
}
/**
* 菜单的方法
*/
public static void caidan() {
// TODO Auto-generated method stub
while (true) {
System.out.println("请输入您的操作:0 退出 1 最大值 2 最小值 3 排序 ");
Scanner input = new Scanner(System.in);
int n = input.nextInt();
switch (n) {
case 1:
zuidazhi();
break;
default:
break;
}
}
}
public static void zuidazhi() {
System.out.println("最大值");
}
}
1.5 总结:.
- 数组的应用,主要和循环一起处理，解决了一些常见的算法问题
- 二维数组
1.6 作业：
