JAVA_Day04

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；空指针；





        }

    }*/