记录自己看渡一教育免费java基础课的学习过程。
int score = 90;
根据score成绩来进行区间的判定 不及格 及格 中等 良好 优秀 满分…
score是一个变量空间(小容器)—一个学生的成绩
变量 类型定义int 空间内的内容只能存放一份
5个同学成绩都存起来???----5个变量【以往的学习】
数组(容器)
- 数组是一组数据类型相同的数据的组合，将这些数据统一的管理起来。
- 数组本身是一个引用数据类型，数组内存储的类型可以是基本类型，也可以是引用类型。
- 数组的特点
(1)数组本身是一个引用数据类型
(2).数组是在堆内存中的一串连续的地址存在
(3).数组在初始化时必须指定长度
(4).堆内存的数组空间长度一旦确定 不能再次发生改变
(5).栈内存的变量中存储的是数组的地址引用
(6).数组内部存储的类型可以是基本的 也可以是引用
-
数组的定义(声明)
数据类型[] 数组名字;
int[] x;
char[] y;
boolean[] z;
String[] m; -
数组的赋值(初始化)
静态初始化 ：有长度 有元素
int[] array = {10,20,30,40,50};
int[] array = new int[]{10,20,30};
动态初始化 ：有长度 没有元素(不是真的没有 默认值)
int[] array = new int[5];
整数默认值—0
浮点数默认值—0.0
字符型默认值— 0—char比如97-a 但0的char值打不出来
布尔型默认值— false
引用数据默认值— null String[]
正常的引用类型初始化都有new，只有Math.random()没有new，因为Math类中只有这一个static的方法。
-
数组元素的访问
通过元素在数组中的位置来访问；
存值/取值；
位置---->index索引；
索引是有取值范围：[从0开始-----数组长度-1]；
如果数组的索引超出了上述范围，编译通过，但是执行失败，会出现一个运行时异常：ArrayIndexOutOfBoundsException。 -
数组元素的遍历(轮询)
通过循环的方式访问数组的每一个元素。
JDK1.5版本之前：
for( ; ; ){
}
具体代码：
for(int index=0;index<5;index++){//每一次做一样的事情 取数组的值 5次
int value = array[index];
System.out.println(value);
}
JDK1.5版本之后：新的特性 增强for循环 加强for forEach
for(自己定义的变量(接收数组内每一个元素) : 遍历的数组array){
}
具体代码：
for(int value : array){
System.out.println(value);
}
正常的for循环以及加强的for循环都需要非常熟练
1.正常的for：
有三个必要条件 index索引 找到某一个元素的位置
好处：可以通过index直接访问数组的某一个位置 ，存值 、取值都可以
不好：在于写法相对来说比较麻烦
2.增强的for：
有两个条件，用来取值的变量，用来遍历的数组，没有index索引
好处：写法相对比较容易
不好：只能取值 不能存值
没有index索引 找不到元素到底是哪一个
- 基本数据类型和引用数据类型在内存结构上的区别
public class TestArray{
public static void main(String[] args){
int a = 10;
int b = a;
b = 100;
System.out.println(a);//? 10
int[] x = new int[]{10,20,30};//拓哥x 记录一个教室号码 3个同学 小拓y 教室里第一个同学罚站
/*栈内存中的小容器 类型定义了只能存储这种东西 容器中只能存一份
见到new关键字 相当于 在堆内存中申请开辟一块新的空间
数组在堆内存的空间形态 是一串连续的地址
基本类型变量空间存储的是值，传递的就是值，一个改变，另一个不变
引用类型变量空间存储的是地址(引用)，传递的就是引用，一个改变，
另一个跟着改变*/
int[] y = x; //传过去的实际上是一个三角号地址
y[0] = 100;
System.out.println(x[0]);//? 100
}
}
-
所有的变量空间都存储在栈内存
-
变量空间可以存储基本数据类型 也可以存储引用数据类型
-
如果变量空间存储的是基本数据类型 存储的是值 一个变量的值改变 另一个不会跟着改变
-
如果变量空间存储的是引用数据类型 存储的是引用(地址) 一个变量地址对应的值改变 另一个跟着改变
-
习题一：
创建一个数组，用来存储1-100之间的偶数。
public class SaveNum{
public static void main(String[] args){
//1.需要创建一个数组
int[] array = new int[50];//有长度 元素没有(默认值)
//2.需要将1-100之间的偶数存入数组内
for(int i=0;i<array.length;i++){//执行50次 从几数都可以 觉得从0开始数比较方便
array[i] = 2*i+2;
}
//3.输出验证看一看
for(int v:array){
System.out.println(v);
}
}
}
设计程序的时候出现的小问题
(1)创建一个数组 动态初始化???
静态 :元素个数比较少 ; 元素很多没规律
动态:元素个数很多有规律
(2)用了两个循环 一个只为了存值 另一个只为了输出看一看
存放时直接看结果可能由于存放误操作—看时正确 之后就发生变化
存放不一定必须要查看 存放是一件事情 查看是另一件
- 创建一个数组用来存储1-100之间的奇数
public class Jishu {
public static void main(String[] args){
int[] nums=new int[50];
for(int i=0;i<50;i++){
nums[i]=2*i+1;
}
for(int j=0;j<50;j++){
System.out.println(nums[j]);
}
}
}
- 给定两个数组a{1,2,3,4} b{5,6,7,8} 将两个数组内的元素对应位置互换。
方法一：交换数组中对应的元素(循环次数好多次 受长度的限制)
public class Test1{
//1.给定两个数组a{1,2,3,4} b{5,6,7,8} 将两个数组内的元素对应位置互换
public static void main(String[] args){
//1.创建两个数组
int[] a = {1,2,3,4};
int[] b = {5,6,7,8};
//2.元素对应位置的互换 ---- 每一次交换两个数字 换四次
//方式一 交换数组中对应的元素(循环次数好多次 受长度的限制)
for(int i=0;i<a.length;i++){//为了控制四次
int x = a[i];
a[i] = b[i];
b[i] = x;
}
//3.分别输出两个数组元素看一看
for(int v:a){
System.out.println(v);
}
System.out.println("--------");
for(int v:b){
System.out.println(v);
}
}
}
方法二：
public class Test1{
public static void main(String[] args){
//1.创建两个数组
int[] a = {1,2,3,4};
int[] b = {5,6,7,8,9,0};//方法2
//2.元素对应位置的互换 ---- 每一次交换两个数字 换四次
//方式二 直接交换变量a和b中的数组引用(地址) 没有循环一次搞定啦 不受长度限制
int[] temp = a;
a = b;
b = temp;
//3.分别输出两个数组元素看一看
for(int v:a){
System.out.println(v);
}
System.out.println("--------");
for(int v:b){
System.out.println(v);
}
}
}
黑色是第一种方法，红色是第二种方法内存图。
a和b实际上就是一个门排号（地址）
- 给定一个数组a{1,2,3,4,5,6} 将这个数组中的元素头尾对应互换位置
public class Test2{
//2.给定一个数组a{1,2,3,4,5,6} 将这个数组中的元素头尾对应互换位置
public static void main(String[] args){
int[] array = {1,2,3,4,5};
for(int i=0;i<array.length/2;i++){//控制交换的次数 数组长度的一半
int x = array[i];
array[i] = array[(array.length-1)-i];
array[(array.length-1)-i] = x;
}
for(int v:array){
System.out.println(v);
}
}
}
- 给定一个数组a{1,3,5,7,9,0,2,4,6,8} 找寻数组中的最大值和最小值(极值问题)
public class Test4{
//*4.给定一个数组a{1,3,5,7,9,0,2,4,6,8} 找寻数组中的最大值和最小值(极值问题)
public static void main(String[] args){
//买一件衬衫 百货商场 最便宜的
//第一家 200块 记录一下200(小本本 脑子里)
//第二家 180块 如果比记录的这个便宜 抹去记录的信息 重新记录 小本本180
//第三家 250块 如果比记录的小本本数据贵 算啦继续找下一家
//第四家 50块 如果比小本本便宜 抹去 重新记录 小本本50
//以上是分析的思路
int[] a = {1,3,5,7,9,2,4,6,8};
//1.创建一个变量 当作小本本 记录信息
int min = a[0];
int max = a[0];
//2.挨个寻找数组中的元素 与变量中的元素进行比较
for(int i=1;i<a.length;i++){
if(a[i]<min){
min = a[i];
}
if(a[i]>max){
max = a[i];
}
}
System.out.println("数组中的最小值为:"+min);
System.out.println("数组中的最大值为:"+max);
}
}
- 给定两个数组a{1,2,3} b{4,5} 合并两个数组 (创建一个新的数组5长度)
public class Test5{
//5.给定两个数组a{1,2,3} b{4,5} 合并两个数组 (创建一个新的数组5长度)
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];//只有长度 元素默认值0
//3.思路二:想要将新数组填满,两种思路不同循环不同
for(int i=0;i<newArray.length;i++){
if(i<a.length){//新数组的索引位置还没有a数组长度以外的范围
newArray[i] = a[i];
}else{
newArray[i] = b[i-a.length];
}
}
//3.思路一:分别将a和b数组中的元素存入新数组内，两种思路不同循环不同
/*
for(int i=0;i<a.length;i++){//将所有a数组元素存入新数组内
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}
*/
//4.验证一下看一看
for(int v:newArray){
System.out.println(v);
}
}
}
- 给定一个数组a{1,2,3,9,4,5} 按照数组中的最大值位置 将数组拆分成两个{1,2,3} {4,5}
public class Test6{
//6.给定一个数组a{1,2,3,9,4,5} 按照数组中的最大值位置 将数组拆分成两个{1,2,3} {4,5}
public static void main(String[] args){
//1.需要一个数组
int[] oldArray = {1,2,3,90,4,5,6,4,5,6,7,8};
//2.找寻最大值的索引位置-->为了通过这个位置 确定两个小数组的长度
int max = oldArray[0];//数组的第一个元素值
int index = 0;//数组的第一个索引位置----(如果有两个最大值，扩展需要一个数组用来记录所有最大值的索引位置)
for(int i=1;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);
}
System.out.println("------");
for(int v:newb){
System.out.println(v);
}
}
}
- 给定一个数组a{1,2,3,0,0,4,5,0,6,0,7} 去掉数组中的0元素 (创建一个新数组 短的 非零元素挑出来)
int index = 0;//控制新数组的索引变化
好聪明，新变量用于记录新数组顺序
public class Test7{
//*7.给定一个数组a{1,2,3,0,0,4,5,0,6,0,7} 去掉数组中的0元素 (创建一个新数组 短的 非零元素挑出来)
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];
//4.将原数组中非零元素挑出来 存入新数组中
//新数组长度和原数组长度不是一一对应！！！所以自己动自己的就可以了。
int index = 0;//控制新数组的索引变化
for(int i=0;i<oldArray.length;i++){
if(oldArray[i]!=0){
newArray[index++] = oldArray[i];
//index++;
}
}
//5.旧数组我觉得没有用啦 删掉
oldArray = null;
//5.验证新数组看一看
for(int v:newArray){
System.out.println(v);
}
}
}
- 创建一个数组 存储2-100之间的素数(质数)
方法一：
public class Test8{
//8.创建一个数组 存储2-100之间的素数(质数)
//思路一:空间占用小 执行效率慢
//0.通过一个几千次循环找寻一个---count
//1.创建一个数组 长度(刚好的 没有一个空间多余)
//2.通过一个几千次循环找寻素数 将素数存入数组内
public static void main(String[] args){
//0.找寻2-100之间素数的个数--->确定数组的长度
int count = 0;//用来记录素数的个数
for(int num=2;num<=100;num++){
boolean b = false;//标识 用来记录最初的状态
for(int i=2;i<=num/2;i++){//从2--8之间找寻还有没有其他可以整出的数字
if(num%i==0){//如果还有能整出的数字 证明num不是素数
//System.out.println(num+"不是素数");
b = true;//如果满足条件(找到整除 证明不是素数 改变标识)
break;
}
}
if(!b){//如果标识与最初的一致 证明循环内的if从来没有执行过 !b <===> b==false
//System.out.println(num+"是素数");
count++;
}
}
System.out.println("经过找寻,2-100之间素数的个数为:"+count);
//1.创建一个数组 存素数
int[] primeNumberArray = new int[count];
//2.找寻2-100之间的素数 将找到的素数存入数组内
int index = 0;//创建一个新的变量 记录素数数组的索引变化
for(int num=2;num<=100;num++){
boolean b = false;//标识 用来记录最初的状态
for(int i=2;i<=num/2;i++){//从2--8之间找寻还有没有其他可以整出的数字
if(num%i==0){//如果还有能整出的数字 证明num不是素数
//System.out.println(num+"不是素数");
b = true;//如果满足条件(找到整除 证明不是素数 改变标识)
break;
}
}
if(!b){//如果标识与最初的一致 证明循环内的if从来没有执行过 !b <===> b==false
//System.out.println(num+"是素数");
primeNumberArray[index++] = num;
}
}
//3.输出最终的数组验证一下
for(int v:primeNumberArray){
System.out.println(v);
}
}
}
方法二：
public class Test8{
//8.创建一个数组 存储2-100之间的素数(质数)
public static void main(String[] args){
//思路二:执行效率高 空间占用大
//0.创建一个足够长的数组
//1.通过几千次循环找素数 将素数存入数组内
//2.将存入素数的数组 后面部分0元素去掉
int[] primeNumberArray = new int[50];
int index = 0;//记录素数数组索引变化 同时记录素数的个数
for(int num=2;num<=100;num++){
boolean b = false;//标识 用来记录最初的状态
for(int i=2;i<=num/2;i++){//从2--8之间找寻还有没有其他可以整出的数字
if(num%i==0){//如果还有能整出的数字 证明num不是素数
//System.out.println(num+"不是素数");
b = true;//如果满足条件(找到整除 证明不是素数 改变标识)
break;
}
}
if(!b){//如果标识与最初的一致 证明循环内的if从来没有执行过 !b <===> b==false
//System.out.println(num+"是素数");
primeNumberArray[index++] = num;
}
}//{2,3,5,7,11,13,17,19,23,29...........0,0,0,0,0,0,0,0,0}
int[] newArray = new int[index];
for(int i=0;i<newArray.length;i++){
newArray[i] = primeNumberArray[i];
}
primeNumberArray = null;//
for(int v:newArray){
System.out.println(v);
}
}
}
- 数组元素的排序
- 冒泡：从数组最底端向上冒泡
public class Test9{
public static void main(String[] args){
//int[] array = {5,2,3,1,4};
//升序排列 --> {1,2,3,4,5} 本质元素位置互换 交换位置的条件
//冒泡排序的算法
int[] array = {5,2,3,1,4};
for(int i=1;i<5;i++){//控制比较轮次 每一轮冒出来一个最小值
//a[4]======a[3]
//a[3]======a[2]
//a[2]======a[1]
//a[1]======a[0]
//for(int j=4;j>=1;j--){//从数组底端 一直比到顶端 4次
for(int j=4;j>=i;j--){//比上一行做了优化
if(array[j]<array[j-1]){
int x = array[j];
array[j] = array[j-1];
array[j-1] = x;
}
}
}
for(int v:array){
System.out.println(v);
}
}
}
- 用户的登录认证(用数组当作小数据库 存值 用户验证)
登录
用户输入用户名 郑中拓 密码 123
注册时存储的真实账号密码–>数据库(数组)
“郑中拓” 123
“渡一教育” 666
“Java” 888
String[] userBox = {“郑中拓”,“渡一教育”,“Java”};
int[] passwordBox = {123,666,888}；
1.需要一个存储真实账号密码的地方(小数组–充当数据库)
2.需要用户输入用户名和密码
3.比对
先比账号 账号是唯一存在的(主键primary key约束)
登录成功(都对啦)
密码错误
用户名不存在
import java.util.Scanner;
public class Zonghe{
public static void main(String[] args){
//1.需要一个存储真实账号密码的地方(小数组--充当数据库)
String[] userBox={"郑中拓","渡一教育","Java"};
int[] passwordBox = {123,666,888};
//2.需要用户输入用户名和密码
Scanner input=new Scanner(System.in); //无论输入多少次，这句只需要一次就够了
System.out.println("请输入用户名：");
String user=input.nextLine();
System.out.println("请输入密码：");
int password=input.nextInt();
//用于标记
boolean x = false; //用于：如果if中从未执行，说明用户名不存在，再用来输出用户名错误
//3.比对
for(int i=0;i<userBox.length;i++){
if(userBox[i].equals(user)){ //如果用户存在 下一步应当比对密码
//比对密码
if(password==passwordBox[i]){
System.out.println("登陆成功");
}
if(password!=passwordBox[i]){
System.out.println("输入密码错误");
}
x=true;
}
}
if(x==false){
System.out.println("用户名不存在");
}
}
}
/*
equals和==区别
equals： 引用类型：Objec类比较的是地址值，
但是继承他的类大都重写了equals方法比较成员变量的值是否相同。
==：基本类型：比较值是否相同。
引用类型：比较内存地址是否相同。
面试题：equals和==区别？
equals比较的是两个字符串内容是否相等
==比较的是两个字符串的内存地址是否相同。
所以以后比较两个字符串内容是否相等要用equals();
*/
多维数组：
二维数组：
- 定义/声明
里面存储的类型[] 数组名字;
int[][] array; - 初始化
静态—有长度 有元素
int[][] array = {{1,2},{3,4,5,6},{7,8,9}};
动态—只有长度 没有元素(默认)
int[][] array =new int[3][2];
array—>{{x,x},{x,x},{x,x}}—> x默认值0
可能会产生一个运行时异常
NullPointerException - 元素访问
通过元素在数组中的位置—index
array[i][j]
i控制大数组中 小数组的位置
j控制小数组中 元素的位置
array.length表示：大数组中有多少个小数组
array[i].length表示：大数组中的第i个小数组中有多少个元素。
静态数组访问：
//静态数组访问元素
public class TestArray{
public static void main(String[] args){
//声明----初始化(静态)
int[][] array = new int[][]{{1,2},{3,4,5,6},{7,8,9}};
//访问数组内的元素---index
//int value = array[0][0];//前面表示小数组位置 后面表示小数组中元素的位置
//System.out.println(value);//1 array[1][2];//5 array[2][2];//9
//数组的遍历/轮询
for(int i=0;i<array.length;i++){//遍历大数组中的小数组
for(int j=0;j<array[i].length;j++){//遍历每一个小数组中的元素 array[i]表示小数组
int value = array[i][j];
System.out.print(value+"\t");
}
System.out.println();
}
System.out.println("-------第二种遍历方式------");
for(int[] arr : array){
for(int value : arr){
System.out.print(value+"\t");
}
System.out.println();
}
}
}
动态数组访问：
public class TestArray{
public static void main(String[] args){
//二维数组的动态初始化
//int[][] array = new int[3][2];//{{0,0},{0,0},{0,0}}
//array[0][0] = 10;
//array[0][1] = 20;
//array[0][2] = 30;//运行时异常ArrayIndexOutOfBoundsException
}
}
- 遍历轮询
正常 增强for循环 嵌套完成 - 引用类型在内存中的存储结构
二维数组在内存中的存储
int[][] array = new int[3][];
//3表示有3个小数组 int[]
//2表示每一个小数组内有2个元素---->表示小数组的长度
array[0][0] = 10; //array[0]找到的是空指针 图片中的绿色
array[0][1] = 20;
//NullPointerException 空指针异常
上面的代码编译不通过，可以改为：
//二维数组的动态初始化
int[][] array = new int[3][];//{{0,0},{0,0},{0,0}}
array[0] = new int[2];
array[0][0] = 10;
array[0][1] = 20；
内存考察的题：
int[][] array = new int[3][2];
array[0][0] = 10;
array[0][1] = 20;
array[1] = array[0];//红色array[0]的地址给了array[1]
array[0] = new int[4];//红色 array[0]变为4个空间
//但是array[1]并没有改变，它仍然指向原来array][0]指向的2个的空间
array[0][0] = 100;
System.out.println(array[1][0]);//? 10
三维数组
创建一个数组 数组内存储好多个 int[][]
int[][][] array = {{{1,2},{3,4}},{{},{}},{{},{}}};
int[][][] array = new int[3][][];
三个二维数组 每一个里面有两个一维数组 再里面有两个int元素
常见的运行时异常
1. InputMisMatchException 输入类型不匹配
input.nextInt(); 输入一个整数 a
2. ArrayIndexOutOfBoundsException 数组索引越界
静态初始化 int[] array = {10,20};
array[2] 索引超出边界
3.NegativeArraySizeException 数组长度不合法(长度出现负数)
动态初始化 int[] array = new int[-2];
4.NullPointerException 空指针异常
引用为null 还拿来使用就不行啦
int[] array = null;
array[0] = 10;//空元素再拿来用
最容易找到异常 同时也是最难找的
习题1.
模拟班级同学每周换位置
{{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}}
经过一周以后为：
{{5,6,7,8},{9,10,11,12},{13,14,15,16},{1,2,3,4}}
import java.util.Scanner;
public class ChangeGroup{
public static void main(String[] args){
//创建一个二维数组 用来表示班级里的每一列同学
int[][] array = {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
//设计每一周交换一次 几周?
Scanner input = new Scanner(System.in);
System.out.println("请您输入一个周数,我来告诉您交换后的结果");
int week = input.nextInt();//6
for(int i=1;i<=week;i++){
//for(int i=1;i<=week%4;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();
}
}
}
2331
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
