笔记01
public class One {
public static void main(String[] args) {
//++ -- 自增 自减 一元运算符
int a = 3;
int b = a++; //a++ a = a + 1 //执行完这行代码后，先给b赋值
System.out.println(a);
//++a a = a + 1 执行这行代码之前，先自增，后给c赋值
int c = ++a;
System.out.println(a);
System.out.println(b);
System.out.println(c);
//幂运算 2^3 2*2*2=8 如何简单快速的计算2^3
double pow = Math.pow(3,2); //3的2c次方
System.out.println(pow);
}
/**
*byte a = 1;
*short b = 2;
*int c = 3;
*long d = 4;
*float e = 3.4F
*double f = 4.5;
*char g = 'a';
*boolean h = true;
/*
/*
a++单目 a+b双目 (a>b)?x:y;三目
+ - * / %(取余，取模)
int x = 1;
x+=2; //3
x=x+2;//3
*/
/*
关系运算(比较)
> >= < <= != == (对象instanceof类)
1.区分= 和 ==区分
= 赋值符号
==比较符号
*/
/*
逻辑运算 与 或 非 异或
& | !(即取反) ^
&&短路与 ||短路或 //逻辑运算符前后应该连接的是boolean值
*/
/*
位运算 &按位与 |按位或 ^按位异或 ~按位取反
<<按位左位移 >>按位右位移 >>>按位右位移(无符号）
byte -- 1字节 -- 8bit
进制转化
十进制 0123456789
二进制01
如何将十进制--->二进制
60-->32个0或1来表示60 60除以2取余数 将余数的倒叙排列即为有效位
00000000 00000000 00000000 00111100
如何将二进制--->十进制
在二进制数组中从右向左进行计算 每一个元素乘以2的位置次幂 然后求和
八进制(01234567) 将3个bit合在一起 代表名为3个bit值转换为十进制的数值
000 000 000 000 111 100
(用来八进制和十进制区分的)0 7 4
十六进制（以0X开头） 将每4个元素（bit）合并成一个转换为十进制的数值
0000 0000 0000 0011 1100
0X 3 C(12) 其中10--A 11--B 12--C 13--D 14--E 15--F
3&5=？
计算方法：1.将3和5转换为二进制
2.竖着按照对应位置进行& | ^计算(1当做ture 0当做false)
3.最后将二级制转换为十进制数值
00000011
00000101
00000001
*/
/* ~6=？ -7
原码 反码 补码 二进制表示数字
6 -6
原码：00000000 00000000 00000000 00000110 10000000 00000000 00000000 00000110
反码：00000000 00000000 00000000 00000110 11111111 11111111 11111111 11111001 符号不动 其余取反
补码：00000000 00000000 00000000 00000110 11111111 11111111 11111111 11111010 反码+1
计算机中不管是整数还是负数 储存形势都是以补码形势来储存
反码是一种表示形式 取反是一个计算过程(每一个位置都取反)
-6>>(>>>)1
11111111 11111111 11111111 11111010
?1111111 11111111 11111111 11111101
>>保留符号位置1 填1
>>>不好留符号 不管是什么都填0
*/
/**
思考：如何最有效率的方法计算2*8的结果
平常过程2转换为二进制 00000010
然后将8转换为二进制 00001000然后计算机会自动乘出结果
即00000010
*00001000
------------
00000000
00000000
00000000
00000010
.....................
然后相加即为 00000010000 == 16
简便算法(乘数刚好是2的次幂或者被乘数是2的次幂，其中计算时方向要调换)
2<<3 （相当于2乘以2的3次幂）
将两个变量的值互相转换
如：int a = 1； int b = 2;
方式一、需要一个空间进行转换(但却有空间的浪费但值不会出现任何的问题)
int c = a;
a = b;
b = c;
方式二(基本没有缺点，除非值过大超出int范围)、 a = a + b;（其中a，b为容器）//a空间内存的是两个元素的和为3 b的数值没有变化为2。
b = a - b;//利用两个元素的和减原来的b剩下是原来的a b1 a3
a = a - b;//此时b存放的为原来a的值也就是1，a空间没有变化还是3，然后通过a-b使得a中获得原来b的值即为2.
方法三(兼容不好，少用)、 a = a ^ b; // 1^2>001
010
0113^2
010
0011
122>1 一个数字异或同一个数字两次，值不会发生改变。
b = a ^ b;
a = a ^ b;
*java语法结构
顺序结构
分支结构 分为单分支结构(if)和多分支结构(switch)
循环结构(重复不停的做同样的事情) for循环 while循环 do...while循环
一、单分支结构(if)
if（值--boolean）可以做单行语句(下一行语句)可用:结束也可以做多行语句用{}结束，但一般都用{}结束
if else语句 if(){
}else{
}
除此之外还有if的嵌套语句即无限if else if语句
如果设计一个小程序 比如帮助我们自己学习英语（星期）
用户输入-->Scanner新建对象 Scanner input = new Scanner(System.in);但是在之前需要import java.util.Scanner；即导入包
接收 int day = input.nextInt(); String day = input.nextLine();
/*
/*
小任务一
import java.util.Scanner;
public class Work{
public static void main(String[] args){
//普通写法
// Scanner input = new Scanner(System.in);
// System.out.println("请输入当前月份");
// int month = input.nextInt();
// if(month12|month1|month2){
// System.out.println("冬天");
// }else if(month3|month4|month5){
// System.out.println("春天");
// }else if(month6|month7|month8){
// System.out.println("夏天");
// }else if(month9|month10|month11){
// System.out.println("秋天");
// }else{
// System.out.println("请输入正确的月份");
// }
//简洁写法
Scanner input = new Scanner(System.in);
System.out.println("请输入当前月份");
int month = input.nextInt();
if (month<1||month>12){
System.out.println("请输入正确的月份");
}else if (month>=3&&month<=5){
System.out.println("春天");
}else if (month>=6&&month<=8){
System.out.println("夏天");
}else if (month>=9&&month<=11){
System.out.println("秋天");
}else{
System.out.println("冬天");
}
}
}
小任务二
== 与 equals();区别
"a"=="b"(可能比的是地址) "a".eauals("b");因此在引用类型中建议用.eauals();
package Work;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
double value = Math.random();
int number = (int)(value*6+1);//类型转换
Scanner input = new Scanner(System.in);
System.out.println("买大买小，买定离手");
String choose = input.nextLine();
System.out.println("本次摇出的点数为："+number);
if ((number<=3 && choose.equals("小"))||(number>3&&choose.equals("大"))){
System.out.println("恭喜您猜对了");
}else {
System.out.println("对不起 猜错了");
}
}
}
*/
/*
二、多分支语句switch（"只能"）
swutch(值--byte short int char 1.5版本后可以加入enum 1.7版本支持String){
case 值1:
代码1；
case 值2:
代码2；
default:
代码；
}
通常情况下因为case贯穿情况在代码后都需要加入break;结束
*/
if 优点(可以写复杂的逻辑) 缺点（执行比较慢）
switch 优点(判断的过程效率更高)缺点 (只能做==(固定值))
/*
用switch编写学生成绩60分以下为不及格60-69及格70-79中等80-89良好90-100优秀
import java.util.Scanner;
public class Work01 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入您的分数");
int score = input.nextInt();
switch (score/10){
case 0；
case 1；
case 2；
case 3；
case 4：
case 5：System.out.println("逃得了课 跳不掉不及格");
break;
case 6:
System.out.println("及格万岁");
break;
case 7:
System.out.println("中等");
break;
case 8:
System.out.println("良好");
break;
case 9:
System.out.println("优秀");
break;
case 10；
if(score==100){
System.out.println("学霸本霸");
break:
}
default ：
System.out.println("你确定你输入的是你的分数而不是你的身份证号？");
}
}
}
*/
=======================================================================================
/*
循环结构 for whilie dp...while
程序中想要执行一个正常的循环，需要三个值 初始值 终点判断条件 变化量
允许将三个必要条件都写在()内
for(初始值;终点判定条件;变化量){//如果需要将初始值放在for循环外，for循环()中依然要有两个;;即(;;)
大量代码
}
如何用计算机帮助解决小学应用题
假设操场上有一百多人，每3人一组多1人，每4人一组多2人，每5人一组多2人，问操场上有几人？
public class Work01 {
public static void main(String[] args) {
for(int x = 100;x<200;x++){
if(x%3==1&&x%4==2&&x%5==2){
System.out.println("这时操场还有:"+x"人");
}
}
}
}
三位数的水仙花题目
for(int num = 100;num<1000;num++){
int b = num/100;
int c = num/10%10;
inr g = num%10
if(b*b*b+c*c*c+g*g*g==num){
System.out.println(num+"是水仙花数");
}
double value = Math.pow(double a,double b);//帮助我们计算a的b次方
上述代码简化为
for(int num = 100;num<1000;num++){
if(Math.pow(num/100)+Math.pow(num/10%10)+Math.pow(num%10)==num){
System.out.println(num+"是水仙花数");
}
/*
循环嵌套
import java.util.Scanner;
public class Work01 {
public static void main(String[] args) {
System.out.println("请输入您想要的*个数");
Scanner input = new Scanner(System.in);
int count = input.nextInt();
for(inr i=1;i<=count;i++){
System.out.println("*");
}
}
int count = 4;
for(inr i=1;i<=count;i++){
for(int j =1;j<=count;j++){
System.out.print("*");
}
System.out.println("");
}
for(inr i=1;i<=4;i++){
//输出星星
for(int j=1;j<=i;j++){
System.out.print("*");
}
//换行
System.out.println();
}
for(inr i=1;i<=4;i++){//控制四行
//画占位符
for(int j=1;j<=4-i;j--){
System.out.print(" ");
}
//画星星
for(int j=1;j<=i;j++){
System.out.print("*");
}
//换行
System.out.println();
}
小练习
public class Demo01{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.print("请您输入行数");
int line = input.nextInt();
for(int i=1;i<=4;i++){
//if(i==1){//单分支结构代码里如果有相同的代码，则可以进行优化
//System.out.print("*******");
for(int j=1;j<=2*line-1;j++){
System.out.print("*")；
}
}else{
for(int j=1;j<=(line+1)-i;j++){
System.out.print("*");
}
for( int j=1;j<=2*i-3;j++){
System.out.print(" ");
}
for(int j=1;j<=(line+1)-i;j++){
System.out.print("*");
}
}
System.out.println();
}
}
}
public class Demo02 {
public static void main(String[] args){
for(int i=1;i<=4;i++){
for(int j=1;j<=4-j;j++){
System.out.print(" ");
}
for(int j=1;j<=i;j++){
System.out.print("j");
}
for(int j=1;j>=i-1;j){
System.out.print("j");
}
}
}
public class Demo03 {
public static void main(String[] args){
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++){
System.out.print("j+"*"+i+"="+(j*i)+"\t");
}
}
System.out.println();
}
}
转义字符 \
可以将身后一个字符的意思发生转换
//转义符号可以转换特殊的符号 比如"" ''
//转义字符还可以转换及格特殊的字母 比如 \n表示换行 \r表示会车(Enter) /t制表符
public class Demo04 {
public static void main(String[] args){
for(int num =2;num<=100;num++){
boolean a = false
for(int i=2;i<=num-1;i++){
if(num%i==0){
System.out.println(num+"不是一个素数")
a = ture;
break;
}
if(a==false){
System.out.println(num+"是一个素数");
}
}
}
}
}
/*
两个关键字
break 在寻找素数的练习中，break--中断循环
continue
两个循环结构
while
do...while
public class Break{
public static void main(String[] args){
for(int i=1;i<=5;i++){
if(i==3){
break;//终止，满足if条件中断循环
}
System.out.println(i);
}
}
}
public class Break{
public static void main(String[] args){
//int i=1;
//int j=1;（如果延长变量的生命周期会改变输出内容）改变只输出2次结果
for(int i=1;i<=5;i++){
for(int j=1;j<=5;j++){
if(j==3){
break；
}
System.out.println("大剑天下第一");
}
}
}
}
public class Break{
public static void main(String[] args){
//int i =1;
//int j =1;(如果延长变量的生命周期会改变输出内容） 改变只输出4次结果
for(int i=1;i<=5;i++){
for(int j=1;j<=5;j++){
if(i==3){
continue;//中断一次过程，程序继续执行
}
}
System.out.println(i);
}
}
}
public class Break{
public static void main(String[] args){
//int i=1;
//int j=1; 无影响
ok:for(int i=1;i<=5;i++){
ko:for(int j=1;j<=5;j++){
if(j==3){
break ok；//中断大循环整个程序只执行两次最终i==1；j==3
}
System.out.println("大剑天下第一");
}
}
}
}
public class Break{
public static void main(String[] args){
//int i=1;
//int j=1;
ok:for(int i=1;i<=5;i++){
ko:for(int j=1;j<=5;j++){
if(j==3){
continue ok；
}//j==3停住一次后继续下一次i++ i=2
System.out.println("大剑天下第一");
}
}
}
}
循环想要执行需要三个必要条件 初始值 终点判定条件 变化量
初始值；
while(终点判定条件){//小括号内只允许写一个终点判定的条件
好多好多执行；
变化量；（在循环里的位置放在执行的上下输出的结果是不一样的）
}
初始值；
do{
好多好多执行；
变化量；
}while(终点判定条件)
while循环小程序 有一水池已装120立方米水，有一进水管每小时进水18立方米，另一排水管每小时排水30立方米
经过多少小时 水池的水排放干净？
public class Demo01{
public static void main(String[] args){
int sum = 120;//表示水池里的水
int hour = 0;//记录经过小时数
while(sum>0){
sum+=18;
sum-=30
sum++
System.out.println("本次循环完毕："+sum);
}
System.out.println("要经过"+hour+"小时");
}
}
public class Demo01{
public static void main(String[] args){
int i=1;
while(i<=4){
int j =1;
while(j<=4-i){
System.out.print(" ");
j++;
}
int k =1;
while(k<=2*i-1){
System.out.print("*");
k++;
}
System.out.println();
i++;
}
}
}
*/
*/
数组
数组是一组数据类型相同的数据的组合，将这些数据统一的管理起来
数组是一个引用数据类型，数组内存存储的类型可以是基本类型，也可以是引用类型
数组的特点：
1.数组是一个引用数据类型
2.数组是在堆内存中的一串连续的地址存在
3.数组在初始化时必须规定长度
4.堆内存的数组空间长度一旦确定 不能再次发生改变
5.栈内存的变量中存储的是数组的地址引用
6.数组内存存储的类型可以是基本的，也可以是引用的
一、数组的定义（声明）
1.数据类型用[]表示
2.数组的名字
如：
int[] x;
char[] y;
boolean[] z;
String[] m;
int[] x; int x[]; int []x三样写法都可以
二、数组的赋值（初始化）
1.静态初始化 有长度 有元素
int[] array = new int[]{10,20,30,40,50};
int[] array ={10,20,30,40,50};
int[] array;
一百行代码
array = new int[]{};
2.动态初始化 有长度 无元素（不是真的没有 而是为默认值0） 浮点数默认值
int[] array = new int[5];
3.数组元素的访问
通过元素在数组的位子index（索引 下标）来访问
位置--->index索引
索引是有取值范围的
如果数组的索引超出上述范围 会出现一个运行时的异常ArrayIndexOutOfBoundsException
4.数组元素的遍历（轮询）
将数组里的每一个元素都拿出来执行
JDK1.5版本之后 新的特性 增强for循环（forEach）
增强for循环（forEach）结构
增强的for循环有两个条件 写法较为容易 只能取值不能存值
没有index索引 找不到元素到底是哪一个
for(自己定义的变量(为了接手数组内的每一个元素):遍历数组的array)[
]
for(int value:array){
System.out.println(value);
}
正常for循环可以通过index直接访问数组的某一位置 存值 取值都可以
for(int index=0;i<5;index++){//每次做一样的事情，取数组的值
int value = array[index];
System.out.println(value);
}
public class Demo01{
public static void main(String[] args){
int[] array = new int[]{10,20};
//array[index];
从数组内取得某一个元素 数组内从0开始数 0~9
int value = array[4];
System.out.println(value);
array[2] = 400;//向数组内的某一个位置存入元素
索引有范围
int value = array[5];
System.out.println(value);
//异常---运行时异常 inputMisMatchException输入类型不匹配
ArrayIndexOutOfBoundsException 数组索引越界
//index索引 0开始----数组（长度-1）结束
NegativeArraySizeException 运行时异常 创建数组的时候长度不合法
}
}
三、基本数据类型和引用类型的
int[] x={10,20,30,40};
栈内存到底小容器只能存放一份元素
new关键词 相当于在堆内存中申请开辟一块新的空间
数组在堆内存的空间形态 是一串连续的地址
基本类型变量空间储存的是值 传递的就是值
引用类型变量空间储存的是引用数据类型 存储的是引用（地址） 一个变量地址对应的值改变 另一个跟着改变
int[] y= x;
y[0] = 100;
System.out.println(x[0]);//输出 100
需求
1.创建一个数组 用来存储1-100之间的偶数
元素个数较少 静态初始化
元素个数较多且有规律可循 动态初始化
2.用了两个循环 一个只为了存值 另一个只为了输出结果
存放时直接看结果可能由于存放误操作---看时正确 之后就发生变化
存放不一定必须要查看 存放是一件事情查看是另一件；
public class Demo05{
public static void main(String[] args){
//1.创建一个数组
int[] array = new int[50];
//2.需要将1-100之间的偶数存入数组内
for(int i=0;i<array.length;i++){//执行50次
//存值
array[i] = 2*i+2
}
//3.输出验证看一看(非必要)
for(int v:array)
System.out.println("v");
}
}
小任务
给定两个数组a{1,2,3,4} b{5,6,7,8}将两个数组内的元素对应位置交换
public class Test{
public static void main(String[] args){
//创建两个变量
int[] a= {1,2,3,4};
int[] b= {5,6,7,8};
//元素对应位置的互换 --- 每一次交换两个数字 换四次
方式一 交换数组对应的元素 循环多次得 受限于长度
for(int i=;i<=a.length;i++}{
int x=a[i];
a[i] = b[i];
b[i] = x;
}
方式二 直接交换变量a和b中的数组引用（地址）没有循环一次搞定 不受长度受限
int[] temp = a;
a = b;
b = temp;
for(int v:a){
System.out.println(v);
}
for(int j:b){
System.out.println(j);
}
}
2.给定一个数组数组a{1,2,3,4，5,6}将这个数组中的元素头尾对应互换位置
public class Test{
public static void main(String[] args){
int[] array = {1,2,3,4,5,6};
//a[0]---a[5]
//a[1]---a[4]
//a[2]---a[3]
for(int i=0;i<3;i++){//i<3==i<array.length/2
int x = array[i];
array[i] = array[5-i];//5-i==(array.length-1)-i
array[5-i] = x;
}
for(int v:array){
System.out.println(v);
}
}
}
3.给定一个数组a{1,3,5,7,9,0,2,4,6,8}找寻数组中的最大值和最小值（极值问题）
public class Test{
public static void main(String[] args){
int[] a={1,3,5,7,9,0,2,4,6,8};
1.常见一个变量 记录信息方便比对
int min = a[0];
int max = a[0];
2.挨个找寻数组中的元素 与变量的元素进行比较
for{int i=0;i<array.length;i++}{
if(a[i]<min)
min = a[i];
}
if(a[i]>max)
max = a[i];
}
}
System.out.println("数组的最小值为"+min);
System.out.println("数组的最大值为"+max);
}
5.给定两个数组a{1,2,3} b{4,5}合并连个数组（创建一个新的数组长度为5）
public class Test{
public static void main(String[] args){
//1.创建两个数组
int[] a = {1,2,3};
int[] b = {4,5};
//2.因为数组长度一旦确定 不能再次改变 需要创建一个新的数组
int[] newArray = new int[a.length+b.length];//[5]动态初始化只有长度 元素默认值为0
思路二 将新数组填满
for(int i=0;i<newArray.length;i++){
if(i<a.length){//新数组的索引位置还没有a数组长度以外的范围
newArray[i] = a[i];
}else{
newArray[i] = b[i-a.length];
}
}
思路一 分别将a和b数组中的元素存入新数组
for{int i=0;i<a.length;i++}{
newArray[i] = a[i];
}//newArray--->{1,2,3,0,0}
for{int i=0;i<b.length;i++}{//将b数组元素取出来 存入新数组后面位置
newArray[a.length+i] = b[i];
}//newArray--->{1,2,3,4,5}
for{int v:newArray}{
System.out.println(v);
}
}
}
6.给定一个数组a{1,2,3,4,5}按照数组中的最大值位置 将数组拆分成两个{1,2,3}{4,5}
public class Test{
public static void main(String[] args){
//1.主要一个数组
int[] oldArray = {1,2,3,4,5}
//2.找寻最大值的索引位置--->为了通过这个位置 确定两个小数组的长度
int max = oldArray[0];
int index = 0;//数组的第一个索引的位置
for(int i=0;i<oldArray.length;i++){
if(oldArray[i]>max){
max = oldArray[i];
index = i;
}
}
System.out.println("最大值为："+max);
System.out.println("最大大位置为："+index);
//3.需要两个小数组分别承载元素
int[] newa = new int[index];
int[] newb = new int[oldArray.length-index-1];
//4.分别将两个小数组填满
for(int i=0;i<newa.length;i++){
newa[i] = oldArray[i];
}
for(int i=0;i<newb.length;i++){
newb[i] = oldArray[(index+1)+i];
}
//4.分别验证两个新数组
for(int v:newa){
System.out.println(v);
}
for(int j:newb){
System.out.println(j);
}
}
}
7.给定一个数组a{1,2,3,0,0,4,5,0,6,0,7}去掉数组中的0元素（创建一个新数组 短的 非0元素挑出来）
public class Test{
public static void main(String[] args){
//1.需要一个数组
int[] oldArray = new int[]{1,2,3,0,0,4,5,0,6,0,7};
//2.找寻原数组中的非零元素的个数--->才能确定新数组的长度
int count = 0;
for(int i=0;i<oldArray.length;i++){
if(oldArray[i]!=0){
count++
}
}
System.out.println("原数组非零元素的个数"+count);
//3.创建一个新的数组 装原数组中的非零元素
int[] newArray = new int[count];//思路二-->可以创建一个足够长的数组oldArray.length//可省略前面找寻长度的过程 但内存占用较大
//4.将原数组中非零元素挑出来 存入新数组内
int index = 0;//控制新数组的索引变化
for(int i=0;i<oldArray.length;i++){
if(oldArray[i]!=0){
newArray[index] = oldArray[i] //index可替换为index++
index++
}
}
//删除 旧数组
oldArray = null;
//5.验证新数组
for(int v:newArray){
System.out.println(v);
}
}
}
8.创建一个数组 存储2-100之间的素数（质数）
public class Test{
public static void main(String[] args){
//一、思路一
//1.找长度
int count = 0;//标识 用来记录数组长度
for(int num=2;num<=100;num++){
boolean b = false;//做标识
for(int i=1;i<=num/2;i++){//2-8之间找寻还有没有其他可以整除的数字
if(num%i==0){//如果还有能整除的数值 证明num不是素数
System.out.println(num+"不是素数");
b = ture;//如满足条件
break;
}
}
if(!b)//!b--------->b == false {/如果标识与最初的一致 证明循环内的if从来没有执行过
//System.out.println(num+"是素数");
count++;
}
}
}
System.out.println("数组长度为："+count);
//2.创建一个数组 存素数
int[] primeNumberArra =new int[];
//3.找寻2-100之间的素数 将找到的素数存入数组内
int index = 0;//创建一个新的变量 记录素数数组的索引变化
for(int num=2;num<=100;num++){
boolean b = false;//做标识
for(int i=1;i<=num/2;i++){//2-8之间找寻还有没有其他可以整除的数字
if(num%i==0){//如果还有能整除的数值 证明num不是素数
System.out.println(num+"不是素数");
b = ture;//如满足条件
break;
}
}
if(!b)//!b--------->b == false {/如果标识与最初的一致 证明循环内的if从来没有执行过
//System.out.println(num+"是素数");
primeNumberArra[index++] = num;
}
}
//4.输出
for(int v:primeNumberArra){
Ststem.out.println(v);
}
思路二、 //0.创建一个足够长的数组
int[] primeNumberArra = new int[50];
int index = 0;
//2.通过几千次循环的数组 将素数存入数组内
//3.去掉多余的零
for(int num=2;num<=100;num++){
boolean b = false;//做标识
for(int i=1;i<=num/2;i++){//2-8之间找寻还有没有其他可以整除的数字
if(num%i==0){//如果还有能整除的数值 证明num不是素数
System.out.println(num+"不是素数");
b = ture;//如满足条件
break;
}
}
if(!b)//!b--------->b == false {/如果标识与最初的一致 证明循环内的if从来没有执行过
//System.out.println(num+"是素数");
primeNumberArra[index++] = num;
}
}
int[] newArray = new int[index];
for(int=0；i<newArray.length;i++){
newArray[i] = primeNumberArra[i];
}
primeNumberArra = null;
}
}
冒泡排序
for(){//控制行数
for(){//控制比数
if(当前元素与前一个元素比较大小){
三行代码
}
}
}
public class Test(){
public static void main(String[] args){
int[] array = {5,2,3,1,4};
//1.从数组低端 一直必到顶端 4次
for(int c=1;c<5;c++){
for(int i=4;i>=c;i--){
if(array[i]<array[i-1]){
int x =array[i];
array[i] = array[i-1];
array[i-1] = x;
}
]
}
for(int v:array){
System.out.println(v);
}
}
}
10.用户的登陆认证(用数组当做小数据库 存值 用户验证)
public class Test{
public static void main(String[] args){
//1.需要一个存蓄真实账号密码的地方(小数组-充当数据库)
String[] userBox = ("一","二","三");
int[] passwordBox = {"123"."456"."789"};
//用户输入--
Scanner input = new Scanner(System.in);
System.out.println(“请输入您的账号”);
String user = input.nextLine();
System.out.println(“请输入您的密码”);
int password = input.nextInt();
//2.需要用户输入用户名和密码
//3.比对
//先比账号 账号唯一 主键收到primary key约束
//登录成功
//密码错误
//用户名不存在
boolean b = true;
for(int i=0;i<userBox.length;i++){
if(userBox[i].equals(user)){//满足条件证明账号存在 .eaualsb()比较引用类型
if(passwordBox[i]==password){//密码正确
System.out.println("登录成功");
}else{
System.out.println("密码错误");//简化后b = false代替else后输出代码
}
b = false;
break;
}
}if(!b){
//用户名 或 密码 有一个不正确 需要输出
//b标记的值和最初的一样不能改才会输出
System.out.println("用户名不存在");
}
}
}
}
*/
/*
二维数组
数组----是用来存储一组相同数据类型的数据的容器
数组本身是一个引用数据类型[]
数组内部存储的元素可以是基本数据类型 也可以是引用数据类型
学过的引用数据类型
String
Math
Scanner
数组本身[]
需求 想要创建一个数组[]---里面存储好多个小数组int[]
二维数组
1.数组的定义/声明
2.数组的初始化
静态初始化 -- 有长度 有元素
动态初始化 -- 有长度 没有元素(默认值)
3.数组元素的访问
通过元素在数组中的位置---index索引
4.数组元素的遍历/轮询
1.定义/声明
里面存储的类型 [] 数组名字；
int[] [] array;
2.初始化
静态--有长度 有元素
int[] [] array = {{},{},{}};
动态--只有长度 没有元素 (默认)
int[][] array = nwe int[3][2];
array--->{{x,x},{x,x},{x,x}}---> x默认值0
3.元素的访问
通过元素在数组中的位置---index索引
4.遍历轮询
正常 增强for循环 嵌套完成
5.引用类型在内存中的存储结构
二维数组在内存中的存储
public class Test{
public static void main(String[] args){
//1声明 初始化
int[][] array = new int[][]{{1,2},{3,4,5,6},{7,8,9}};
//访问数组内的元素 --index
int[] arr = array[0];
int value = arr{0}; //上述两行代码可以简化为int value = array[0][0];前面的0表示小数组的位置 后面表示小数组中元素的位置
System.out.println(value);//1
//数组元素的遍历/轮询
for(int i =0;i<array.length;i++){//遍历大数组中的小数组
int[] arr = array[i];
for(int j=0;j<arr.length;j++){//遍历每一个小数组中的元素
int value = arr[j];
System.out.print(value+“\t”);
}
System.out.println();
}
System.out.println("============================");
增强for循环
for(int[] arr:array){
for(int value:arr){
System.out.print(value+“\t”);
}
System.out.println();
}
//二维数组的动态初始化
int[][] array = new int[3][2];//{{10,20},{0,0},{0,0}}
array[0][0] = 10;
array[0][1] = 20;
//如果去掉int[][] array = new int[3][2];中第二个[]中的值会出现NullPointerException(空指针异常)
//想要执行不报错 转换为下列代码
int[][] array = new int[3][0];
array[0] = new int[2];
array[0][0] = 10;
int[][] array = new int[3][2];
array[0][0] = 10;
array[0][1] = 20;
array[1] = array[0];
array[0] = new int[4];
array[0][0] = 100;
System.out.println(array[1][0]);// 10
}
}
三维数组
创建一个数组 数组内存储好多个 int[][]
int[][][] array = {{{},{}},{{},{}},{{},{}}};
int[][][] array = new int[3][2][2];
三个二维数组 每一个里面有两个一维数组 在里面有两个int元素
常见的运行时异常
1.InputMisMatchException 输入类型不匹配
在Scanner面向对象中
2.ArrayIndexOutOfBoundsException 数组索引越界
静态初始化 int[] array = {20,30}
array[2] 索引超出边界
3.NegativeArraySizeException 数组长度不合法(数组长度出现负数)
动态初始化 int[] array = new int[-2]
4.NullPointerException 空指针异常
习题
模拟班级同学每周换位置的过程
{{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}}
public class Student{
public static void main(String() args){
//1.创建一个二维数组 用来表示班级里的每一列同学
int[][] array = {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}}
//2.设计每一周换几次 几周
Scanner input = new Scanner(System.in);
System.out.println("请输入你要执行的次数");
int week = input.nextInt();
for(int i=1;i<=week;i++){
int[] x = array[0];
array[0] = array[1];
array[1] = array[2];
array[2] = array[3];
array[3] = x;
}
//简单看一下
for(int[] arr:array){
for(int v:arr){
System.out.print(v+“\t”);
}
System.out.println();
}
}
}
main方法
public static void main(){
}
public 访问权限修饰符 公有的
static 特征修饰符 静态的 有且只有一份
void 方法执行完没有返回值 关键字
main 方法名字 主要的
主方法中的args参数 可否传递？
1.主方法不是我们调用的 它是在JVM虚拟机启动的时候 虚拟机调用的
2.主方法里面有args参数 是一个String[]类型 我们是可以传递参数进去 给JVM
*/、
/*
类 -------------->一类事物
对象------------->具体的事物
*/
ArithmeticException 数学异常 整数/0
