public class ArrayDemo1 {
public static void main(String[] args) {
//格式：
//静态初始化
//完整格式：
//数据类型 [] 数组名 = new 数据类型[]{元素1，元素2....};
//简化格式：
//数据类型 [] 数组名 = {元素1，元素2....};
//需求1：定义数组存储5个学生的年龄
int[] arr1 = new int[]{11,12,13,14,15};
System.out.println(arr1);//[I@776ec8df
/*int[] arr2 = {11,12,13,14,15};
//需求2：定义数组存储3个学生的姓名
String[] arr3 = new String[]{"zhangsan","lisi","wangwu"};
String[] arr4 = {"zhangsan","lisi","wangwu"};
//需求3：定义数组存储4个学生的身高 1.93
double[] arr5 = new double[]{1.93,1.75,1.73,1.81};*/
//double[] arr6 = {1.93,1.75,1.73,1.81};
//System.out.println(arr6);//[D@776ec8df 地址值
//扩展：
//解释一下地址值的格式含义 [D@776ec8df
//[ ：表示当前是一个数组
//D：表示当前数组里面的元素都是double类型的
//@：表示一个间隔符号。（固定格式）
//776ec8df：才是数组真正的地址值，（十六进制）
//平时我们习惯性的会把这个整体叫做数组的地址值。
}
}
public class ArrayDemo2 {
public static void main(String[] args) {
//利用索引对数组中的元素进行访问
//1.获取数组里面的元素
// 格式： 数组名[索引]
int[] arr = {1,2,3,4,5};
//获取数组中的第一个元素
//其实就是0索引上对应的元素
// int number = arr[0];
// System.out.println(number);//1
//获取数组中1索引上对应的数据，并直接打印出来
// System.out.println(arr[1]);//2
//2.把数据存储到数组当中
//格式： 数组名[索引] = 具体数据/变量；
//细节：一旦覆盖之后，原来的数据就不存在了。
arr[0] = 100;
System.out.println(arr[0]);//100
}
}
public class ArrayDemo3 {
public static void main(String[] args) {
//1.定义数组
int[] arr = {1,2,3,4,5};
//2.获取数组里面所有的元素
//格式： 数组名[索引]
/*System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);*/
//利用循环改进代码
//开始条件：0
//结束条件：数组的长度 - 1（最大索引）
/* for (int i = 0; i < 5; i++) {
//i: 0 1 2 3 4
System.out.println(arr[i]);
}*/
//在Java当中，关于数组的一个长度属性，length
//调用方式：数组名.length
//System.out.println(arr.length);
for (int i = 0; i < arr.length; i++) {
//i: 0 1 2 3 4
System.out.println(arr[i]);
}
//扩展：
//自动的快速生成数组的遍历方式
//idea提供的
//数组名.fori
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
public class ArrayDemo4 {
public static void main(String[] args) {
/* 定义一个数组，用来存班级中50个学生的姓名
姓名未知，等学生报道之后，再进行添加。*/
//格式：
//数据类型[] 数组名 = new 数据类型[数组的长度];
//在创建的时候，由我们自己指定数组的长度，由虚拟机给出默认的初始化值
String[] arr = new String[50];
//添加学生
arr[0] = "zhangsan";
arr[1] = "lisi";
//获取
System.out.println(arr[0]);//zhangsan
System.out.println(arr[1]);//lisi
System.out.println(arr[2]);//打印出来的是默认初始化值null
//数组默认初始化值的规律
//整数类型：默认初始化值0
//小数类型：默认初始化值0.0
//字符类型：默认初始化值'\u0000' 空格
//布尔类型：默认初始化值 false
//引用数据类型：默认初始化值 null
int[] arr2 = new int[3];
System.out.println(arr2[0]);//0
System.out.println(arr2[1]);//0
System.out.println(arr2[2]);//0
}
}
public class ArrayDemo5 {
public static void main(String[] args) {
//1.定义一个数组
int[] arr = {1,2,3,4,5};
//长度：5
//最小索引：0
//最大索引：4（数组的长度 - 1）
System.out.println(arr[2]);
//小结：
//索引越界异常
//原因：访问了不存在的索引
//避免：索引的范围
//最小索引：0
//最大索引：（数组的长度 - 1）
}
}
public class InfiniteloopDemo1 {
public static void main(String[] args) {
//for格式的无限循环
/*for(;;){
System.out.println("学习");
}*/
//while格式的无限循环
/*while(true){
System.out.println("学习");
}*/
//注意事项
//无限循环的下面不能再写其他代码了，因为循环永远停不下来，那么下面的代码永远执行不到
while(true){
System.out.println("给女神表白");
}
//System.out.println("女神答应我了");
}
}
public class SkipLoppDemo1 {
public static void main(String[] args) {
//1.跳过某一次循环
for (int i = 1; i <= 5; i++) {
if(i == 3){
//结束本次循环，继续下次循环。
continue;
}
System.out.println("小老虎在吃第" + i + "个包子");
}
}
}
public class SkipLoppDemo2 {
public static void main(String[] args) {
//2.结束整个循环
for (int i = 1; i <= 5; i++) {
System.out.println("小老虎在吃第" + i + "个包子");
if(i == 3){
//结束整个循环
break;
}
}
}
}
public class ArrTest1 {
public static void main(String[] args) {
/*定义一个数组，存储1,2,3,4,5
遍历数组得到每一个元素，求数组里面所有的数据和*/
//分析：
//1.定义一个数组，并添加数据1,2,3,4,5
int[] arr = {1,2,3,4,5};
//求和变量
int sum = 0;
//2.遍历数组得到每一个数据，累加求和
for (int i = 0; i < arr.length; i++) {
//i 依次表示数组里面的每一个索引
//arr[i] 依次表示数组里面的每一个元素
sum = sum + arr[i];
}
//当循环结束之后，sum的值就是累加之后的结果
System.out.println(sum);
}
}
public class ArrTest2 {
public static void main(String[] args) {
/*定义一个数组，存储1,2,3,4,5,6,7,8,9,10
遍历数组得到每一个元素，统计数组里面一共有多少个能被3整除的数字*/
//分析：
//1.定义一个数组 存储1,2,3,4,5,6,7,8,9,10
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//定义一个变量，用来统计次数
int count = 0;
//2.遍历数组得到每一个元素
for (int i = 0; i < arr.length; i++) {
//i 表示数组里面的每一个索引
//arr[i] 表示数组里面的每一个元素
//3.判断当前的元素是否为3的倍数，如果是那么统计变量就需要自增一次。
if(arr[i] % 3 == 0){
// System.out.println(arr[i]);
count++;
}
}
//当循环结束之后，就表示数组里面所有的数字都判断完毕了，直接打印count即可
System.out.println("数组中能被3整除的数字有" + count + "个");
}
}
public class ArrTest3 {
public static void main(String[] args) {
/* 定义一个数组，存储1,2,3,4,5,6,7,8,9,10
遍历数组得到每一个元素。
要求：
1，如果是奇数，则将当前数字扩大两倍
2，如果是偶数，则将当前数字变成二分之一*/
//分析：
//1.定义一个数组，存1,2,3,4,5,6,7,8,9,10
int[] arr = {1,2,3,4,5,6,7,8,9,10};
//2.遍历数组得到每一个元素
for (int i = 0; i < arr.length; i++) {
//i 依次表示数组里面的每一个索引
//arr[i] 依次表示数组里面的每一个元素
//3.对每一个元素进行判断
if(arr[i] % 2 == 0){
//偶数 变成二分之一
arr[i] = arr[i] / 2;
}else{
//奇数 扩大两倍
arr[i] = arr[i] * 2;
}
}
//遍历数组
//一个循环尽量只做一件事情。
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
public class ArrTest4 {
public static void main(String[] args) {
//定义数组求最大值：33,5,22,44,55
//扩展问题：
//1.根据求最大值的思路，自己改写一下求最小智
//2.为什么max要记录为arr[0],默认值不能为0吗？
//不能写0
//max的初始化值一定要是数组中的值。
//3.循环中开始条件一定是0吗？
//循环的开始条件如果为0，那么第一次循环的时候是自己跟自己比了一下，对结果没有任何影响，但是效率偏低
//为了提高效率，减少一次循环的次数，循环开始条件可以写1.
//1.定义数组用来存储5个值
int[] arr = {33,5,22,44,55};
//2.定义一个变量max用来存储最大值
//临时认为0索引的数据是最大的
int max = arr[0];
//3.循环获取数组中的每一个元素
//拿着每一个元素跟max进行比较
for (int i = 1; i < arr.length; i++) {
//i 索引 arr[i] 元素
if(arr[i] > max){
max = arr[i];
}
}
//4.当循环结束之后，max记录的就是数组中的最大值
System.out.println(max);//55
}
}
import java.util.Random;
public class ArrTest5 {
public static void main(String[] args) {
/*需求：生成10个1~100之间的随机数存入数组。
1）求出所有数据的和
2）求所有数据的平均数
3）统计有多少个数据比平均值小*/
//分析：
//1.定义数组
int[] arr = new int[10];
//2.把随机数存入到数组当中
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
//每循环一次，就会生成一个新的随机数
int number = r.nextInt(100) + 1;
//把生成的随机数添加的数组当中
//数组名[索引] = 数据;
arr[i] = number;
}
// 1）求出所有数据的和
//定义求和变量
int sum = 0;
for (int i = 0; i < arr.length; i++) {
//循环得到每一个元素
//并把元素累加到sum当中
sum = sum + arr[i];
}
System.out.println("数组中所有数据的和为：" + sum);
//2）求所有数据的平均数
int avg = sum / arr.length;
System.out.println("数组中平均数为：" + avg);
//3）统计有多少个数据比平均值小
int count = 0;
for (int i = 0; i < arr.length; i++) {
if(arr[i] < avg){
count++;
}
}
//当循环结束之后，就表示我已经找到了所有的比平均数小的数据
System.out.println("在数组中，一共有" + count + "个数据，比平均数小");
//遍历数组，验证答案
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
public class ArrTest6 {
public static void main(String[] args) {
/*需求：定义两个变量，交换两个变量记录的值*/
int a = 10;
int b = 20;
/* //把变量b的值。赋值给了变量a。那么变量a原来的值就被覆盖了
a = b;//a = 20 b = 20
//把变量a的值，赋值给了变量b。
b = a;//a = 20 b = 20
System.out.println(a);//20
System.out.println(b);//20*/
//定义一个临时的第三方变量
//把变量a的值，赋值给了temp
int temp = a;
//把变量b的值，赋值给了a。那么变量a原来记录的值就被覆盖了
a = b;
//就是把变量a原来的值，赋值给了变量b
b = temp;
System.out.println(a);//20
System.out.println(b);//10
}
}
public class ArrTest7 {
public static void main(String[] args) {
/*需求：定义一个数组，将数组中0索引和最大索引出的值进行交换*/
//1.定义一个数组
int[] arr = {1,2,3,4,5};
//2.将数组中0索引和最大索引出的值进行交换
//也是可以利用第三方变量进行交换
int temp = arr[0];
arr[0] = arr[4];
arr[4] = temp;
//3.遍历数组
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
public class ArrTest8 {
public static void main(String[] args) {
/*需求：定义一个数组，存入1,2,3,4,5。交换首尾索引对应的元素。
交换前：1,2,3,4,5
交换后：5,2,3,4,1*/
//1.定义数组存储数据
int[] arr = {1,2,3,4,5};
//2.利用循环去交换数据
for(int i = 0,j = arr.length - 1; i < j; i++,j--){
//交换变量i和变量j指向的元素
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//当循环结束之后，那么数组中的数据就实现了头尾交换
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
import java.util.Random;
public class ArrTest9 {
public static void main(String[] args) {
//需求：定义一个数组，存入1~5。要求打乱数组中所有数据的顺序。
//难点：
//如何获取数组中的随机索引
/* int[] arr = {1,2,3,4,5};
//索引范围：0 1 2 3 4
Random r = new Random();
int randomIndex = r.nextInt(arr.length);
System.out.println(randomIndex);*/
//1.定义数组存储1~5
int[] arr = {1, 2, 3, 4, 5};
//2.循环遍历数组，从0索引开始打乱数据的顺序
Random r = new Random();
for (int i = 0; i < arr.length; i++) {
//生成一个随机索引
int randomIndex = r.nextInt(arr.length);
//拿着随机索引指向的元素 跟 i 指向的元素进行交换
int temp = arr[i];
arr[i] = arr[randomIndex];
arr[randomIndex] = temp;
}
//当循环结束之后，那么数组中所有的数据已经打乱顺序了
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
public class LoopTest1 {
public static void main(String[] args) {
/*朋友聚会的时候可能会玩一个游戏：逢7过
游戏规则：从任意一个数字开始报数，当你要报的数字是包含7或者是7的倍数时都要说过：过
需求：使用程序在控制台打印出1-100之间的满足逢七必过规则的数据*/
//分析：
//个位7 十位7 7倍数
//1 2 3 4 5 6 过 8 9 10 11 12 13 过 15 16 过 18 19 20 过....
//69 过 过 过 过 过 过... 80
//1.得到1~100之间的每一个数字
//开始：1
//结束：100
for (int i = 1; i <= 100; i++) {
//2.判断每一个数字，如果符合规则，就打印过，如果不符合规则就打印真实的数字
if(i % 10 == 7 || i / 10 % 10 == 7 || i % 7 == 0){
System.out.println("过");
continue;
}
System.out.println(i);
}
}
}
import java.util.Scanner;
public class LoopTest2 {
public static void main(String[] args) {
/*需求：键盘录入一个大于等于2的整数 x ，计算并返回 x 的 平方根 。
结果只保留整数部分 ，小数部分将被舍去 。*/
//分析：
//平方根 16的平方根4
// 4的平方根2
// 10
// 1 * 1 = 1 < 10
// 2 * 2 = 4 < 10
// 3 * 3 = 9 < 10
// 4 * 4 = 16 > 10
//推断：10的平方根是在3~4之间。
// 20
// 1 * 1 = 1 < 20
// 2 * 2 = 4 < 20
// 3 * 3 = 9 < 20
// 4 * 4 = 16 < 20
// 5 * 5 = 25 > 20
//推断：20的平方根是在4~5之间。
//在代码当中
//从1开始循环，拿着数字的平方跟原来的数字进行比较
//如果小于的，那么继续往后判断
//如果相等，那么当前数字就是平方根
//如果大于的，那么前一个数字就是平方跟的整数部分
//1.键盘录入一个整数
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int number = sc.nextInt();
//2.从1开始循环判断
//开始：1 结束: number
for (int i = 1; i <= number; i++) {
//用i * i 再跟number进行比较
if(i * i == number){
System.out.println(i + "就是" + number + "的平方根");
//一旦找到了，循环就可以停止了，后面的数字就不需要再找了，提高代码的运行效率。
break;
}else if(i * i > number){
System.out.println((i - 1) + "就是" + number + "平方根的整数部分");
break;
}
}
}
}
import java.util.Scanner;
public class LoopTest3 {
public static void main(String[] args) {
//需求：键盘录入一个正整数 x ，判断该整数是否为一个质数。
//质数：
//如果一个整数只能被1和本身整除，那么这个数就是质数。否则这个数叫做合数
//7 = 1 * 7 质数
//8 = 1 * 8 2 * 4 合数
//分析：
//1.键盘录入一个正整数
//number
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个正整数");
int number = sc.nextInt();//9
//定义一个变量，表示标记
//标记着number是否为一个质数
//true： 是一个质数
//false : 不是一个质数
//表示最初就认为number是一个质数
boolean flag = true;
//2.判断
//写一个循环，从2开始判断，一直判断到number-1为止
//看这个范围之内，有没有数字可以被number整除
for (int i = 2; i < number; i++) {
//i 依次表示这个范围之内的每一个数字
//看number是否能被i整除就可以了
if(number % i == 0){// 9 % 2 = 1
flag = false;
//System.out.println(number + "不是一个质数");
break;
}/*else{
System.out.println(number + "是一个质数");
}*/
}
//只有当这个循环结束了，表示这个范围之内所有的数字都判断完毕了
//此时才能断定number是一个质数
if(flag){
System.out.println(number + "是一个质数");
}else{
System.out.println(number + "不是一个质数");
}
}
}
public class LoopTest4 {
public static void main(String[] args) {
// 100000
// 2 ~ 99999
//循环的次数：将近10万次
//推荐一个简化的思路
//81
//1 * 81
//3 * 27
//9 * 9
//以81的平方根9，为中心
//而且假设 a * b = 81
//那么a和b中，其中有一个必定是小于等于9的。
//另一个是大于等于9的。
//假设，都是大于9 --- 9.1 * 9.1 > 81
//假设，都是小于9 --- 8.9 * 8.9 < 81
//其中一个数字一定是小于等于平方根
//另外一个数字一定是大于等于平方根
int number = 100;
//如果这个范围之内，所有的数字都不能被number整除
//那么number就一定是一个质数。
/* for (int i = 2; i <= number的平方根; i++) {
}*/
}
}
//1.导包
import java.util.Random;
public class LoopTest5 {
public static void main(String[] args) {
//先获取一个随机数。
//范围：0~10
//2.创建对象
Random r = new Random();
//3.生成随机数
//判断技巧：
//在小括号中，书写的是生成随机数的范围
//这个范围一定是从0开始的。
//到这个数-1结束
//口诀：包头不包尾，包左不包右
for (int i = 0; i < 100; i++) {
int number = r.nextInt(10);// 0 ~ 9
System.out.println(number);
}
}
}
import java.util.Random;
public class LoopTest6 {
public static void main(String[] args) {
//需求：
//随机数范围：1~100
//创建对象
Random r = new Random();
//生成随机数
int number = r.nextInt(100) + 1;//1 ~ 100
System.out.println(number);
//秘诀
//用来生成任意数到任意数之间的随机数 7 ~15
//1.让这个范围头尾都减去一个值，让这个范围从0开始 -7 0~8
//2.尾巴+1 8 + 1 = 9
//3.最终的结果，再加上第一步减去的值。
/* Random r = new Random();
int number = r.nextInt(9) + 7;// 7 ~ 15
// 0 ~ 8 + 7
System.out.println(number);*/
}
}
import java.util.Random;
import java.util.Scanner;
public class LoopTest7 {
public static void main(String[] args) {
//需求：程序自动生成一个1-100之间的随机数字，使用程序实现猜出这个数字是多少？
//扩展小需求：加一个保底机制，3次猜不中，直接提示猜中了。
//注意点：
//1.生成随机数的代码int number = r.nextInt(100) + 1;
//不能写在循环的里面的，否则每一次都会产生一个新的随机数
//2.抽奖机制
//用点券去抽水晶
//保底 360次
//计数器
//用来统计当前已经猜了多少次。
int count = 0;
//分析
// 1. 生成一个1-100之间的随机数字
Random r = new Random();
int number = r.nextInt(100) + 1;
System.out.println(number);
// 2. 猜这个数字是多少
Scanner sc = new Scanner(System.in);
while(true){
System.out.println("请输入你要猜的数字");
int guessNumber = sc.nextInt();
//3 . 判断两个数字给出不同的提示
//猜的数字大了，提示 大了
//猜的数字小了，提示 小了
//猜的数字一样，提示猜中了
count++;
if(count == 3){
System.out.println("猜中了");
break;
}
if(guessNumber > number){
System.out.println("大了");
}else if(guessNumber < number){
System.out.println("小了");
}else{
System.out.println("猜中了");
break;
}
}
}
}
单词
