for循环
死循环:
while(true);
for(;;)
循环嵌套:
for()循环 while循环 do-while循环;
外层循环一次:
内层循环n次
for(int i =0; i<3; i++){
for(int j =0; j<3; j++ ){
内外层相乘一共执行9次
for (int i = 1; i <10; i++) { //控制乘数
for (int j = 1; j <=i; j++) 控制被乘数
数组
数组的定义:
数据类型 【】数组名称 = new 数组名称【】;
数组可以分为动态数组和静态数组;
动态数组语法:
int[]a=new int[4];
静态数组有两种写法:
int []a=new int []{1,2,3,4};
int[]a ={1,2,3,4};
数组的遍历
for(int i =o; i<a.length; i++)
system.out.println(a[i])//遍历整个数组 并打印输出
数组遍历可能会用到break; 因为break;可以跳出循环
for (int i = 0; i <score.length; i++) {
System.out.println("请输入第"+(i+1)+"个学生的成绩:");
score[i] = input.nextDouble(); //循环输入值赋给数组;;
既然讲到数组的遍历 那肯定少不了排序的
排序的前提是需要对数组进行遍历
数组排序
排序 何为排序??
排序的前提是有一组数据
排序是排怎么样的序呢?升序还是降序??
大前提是有一个数组 比如
int [] a=new int [4]
冒泡排序
给一组乱序的数据 要你排序 你会怎么做呢?
排序的实质是两个数据的交换位置!!!交换
如果是升序
需要一个什么条件呢?
if(a[i]?a[i+1]) 大于还是小于呢???
if(大于还是小于?)
执行交换
a【i】=a【i+1】
如果3>2?进行交换就变称2,3
即a[i]>a[i+1]实现升序操作;;
1,2,3,4,5
冒泡排序的核心操作就具有双层循环
for (int i=0;i<score.length-1;i++){ //外层循环
for (int j=0;j<score.length-1-i;j++){ 内层循环 length-1-i
if (score[j]>score[j+1]) { //交换操作
int temp = score[j];
score[j] = score[j + 1];
score[j + 1] = temp;
}
}
插入排序
已知是一组排好序的数组
就是在冒泡排序的基础上进行插入
先找到插入的位置
利用a[i]>num 记录索引
index=i;
将索引后面的数据往后移
for(i =length-1;i>index;i–)
重点就是这个for循环就是从最后一个元素往后移
a[i] =a[i-1];
将最后一个多出来的空间填满
最后就是a[index]=num;
for (int i = 0; i <score.length; i++) {
if (score[i]>num){
index=i;
break;//要跳出循环;
}
}
for (int i=score.length-1;i>index;i--){ //第一个位置是[0] 即最后一个位置是[leng-1]
score[i]=score[i-1];
}
score[index]=num;
for (int i = 0; i <score.length; i++) {
System.out.println(score[i]);
}
总结:
冒泡排序
插入排序
求最大/最小值;
都有if
都要有一个中间变量 !!!
冒泡: temp;
插入: 索引: index 记录位置的!!
求最大: max if(max>a[i])
max =a[i];、//这是遍历整个数组 求得最小的值 反之求最大
跟那个交换函数差不多
count++ 计数器
/*1.java基础
java能做些什么;
java能开发;
先有一部jvm虚拟机!!!每个平台都有其jvm
JVM{
windows JVM;
Linux JVM;
MAC JVM;
三个平台的JVM;
JVM是运行java文件的虚拟机; 读取和执行字节码文件 这样每台主机都能运行字节码文件
前提是这台主机是在同一个平台 比如windows;
那么字节码文件是由何得来的?
首先有一个源代码 即是用java语法写的代码语句
java文件经过编译器编译成字节码文件;
编译器 是用DOC命令中的 javac 文件名.java;
运行时 DOC命令中的 java 文件名;
java开发需要配置环境变量
1.需要一个jdk版本
2.找到电脑属性的环境变量;
3.变量值%Java__HOME%的地址是JDK的安装路径;
4.Path的路径是%JAVA_HOME%\bin\; 记得要加个分号; 前后都得加;
开发工具:
1.安装idea;
2.需要一个激活码;
3. 创建一个java工程 选择JDK的安装路径;
第一个程序 helloWorld就敲出来了;
Class HelloWorld{
public static void main (String []args){
System.out.println("HelloWorld");
}
Java的基本数据类型;
byte short int char long float double boolean
byte 1;
char 2;
short 2;
int 4;
float 4;
double 8;
boolean 1;
数据类型的转换:向上自动转换;向下强制转换 要加()
double b,c;
比如:int a = (int) (b+c);//这是强转 将double转换为int;
标识符的选择
类名:首字母大写 其他单词都是头字母大写
变量名:首字母小写,其他单词首字母就都是大写; 即是驼峰命名
常量: 单词全部是大写;
包名:都是小写;
不能以数字开头;
运算符:
1. 算术运算符
2.逻辑运算符 && ||
3.关系运算符 ><=
4.赋值运算符
5.位运算符
Java 语法
1.选择语句
有if elseif
switch(表达式){
case
break;//跟if相比 switch是等值操作 只能用int byte char short
//JDK 7.0引入了String 5.0引入enum类型;
if 可以嵌套if 或者switch;
2.循环语句
有while
do{
}whil(); //while(flag) 定义一个全局变量 在每一个语句后面加 flag=true/false
//判断是否跳出循环;NICE!!
for (int i = 0; i < ; i++) {
}
循环可以相互嵌套
3. break 跟contin语句 用法;
在for循环里
加入if{
break;//中断循环 即跳出循环 后面语句不执行
continu; //跳出本次循环 后面语句不执行 但是还会继续循环下去;
}
数组的定义
数组是个引用数据类型;
声明与定义;
int []a =new int[3];//这是动态定义一个数组 动态赋值数组长度为3
int []b = new int[]{1,2,3};//这是静态定义一个数组,确定了数组长度 不会变
int []c={3,34,4,4};//这也是静态定义一个数组;
只要new一个数组出来 数组就会有默认的一个值;
若只是声明一个数组 但是未定义; 就代表没有在内存中开辟一个空间存放数据;
boolean 默认值为 false;
引用数据类型的默认值为 null;
char 默认的值为 '\u0000'即一个空字符;
数组的常见操作;
1.数组遍历
for(int i =0;i<a.length;i++)
System.out.println(a[i]); //遍历数组;
2.数组最值;
先遍历整个数组 在for循环里加入一个条件 加入一个中间变量 temp
if(temp>a[i])
temp=a[i];
3.数组排序
冒泡排序;
排序的核心就是 两两相互比较 然后记得互换数据位置
排序几轮?
几轮 几次?
一个for循环记录轮数
嵌套一个for循环 几次比较次数;
for (int i = 0; i <a.length-1; i++) { //轮数为数组长度-1
for (int j = 0; j <a.length-1-i; j++) { //比较次数为第i轮比较的次数 即数组长度-1-i数
交换函数 //需要一个中间变量 temp
if(a[i]>a[i+1])
temp = a[i];
a[i] = a[i+1];
a[i+1]= temp;
}
插入排序 //需要中间位置变量 index;
1.找到插入的位置
2. 返回索引的值 return index; //if (a[i]>要插入的数) return index
3.讲index 后面位置的数据 往后移;//a[i]=a[i-1];
4.最后赋值 a[index]=要插入的数;
}
数组就是一个容器 也就是一个特殊的变量;
特点:
1.数组是引用数据类型;
2.可以存多个同类型的数据;
3.数组的长度在运行期间不能够改变
数组里的取值:
1.数组的下标取值a[索引]
2.索引永远比数组长度小一 即数组长度-1;
3.若直接输出数组名称 console显示的是获取数组的首地址的哈希值;
Java 在内存空间中 划分了5块:
1.栈
都是局部变量;
局部变量有:{
1.方法中的参数
2.方法中的变量;
3.变量离开作用域 值在栈里就不存在了;
4.所有的方法(函数)都在栈里面执行;
5.所有方法里面的变量都是随着方法的开始而开始 方法的结束而结束
6.除了静态变量; 静态变量在加载类的时候就一直存在;
2.堆
只要new出来的东西都在堆里面,存在堆里的东西都有一个内存地址
正是这个内存地址才能跟栈里面的引用相匹配;
所有存在堆里的基础数据类型或者引用数据类型都有默认值;
3.方法区;
1.class字节码的信息
2.方法里的基本信息
3.什么main方法啊 函数啊 都在方法区里面
4.方法的执行 在栈里面 不在方法区里面;
4.本地方法栈;
系统;
5.寄存器
CPU;
数组常见的错误:1.ArrayIndexOutOfBoundsException; 数组下标越界;
2.java.lang.NullPointException; 空指针异常
比如 int[]a =null;空指针;
}
}*/