学习笔记05-Java基本语法（四）

循环结构

for循环

格式

for(初始值;判断条件;控制条件)
{ 
     循环体;
}

执行流程
根据初始值和判断条件进行比较，如果比较的结果是true执行循环体，执行控制条件改变初始化值，拿着改变的值再和判断条件进行比较，如果比较的结果是true重复上述操作直到比较的结果是 false才结束循环。
例

class ForDemo{
   public static void main(String[] args) {
//打印10遍
      for(int i=0;i<10;i++){
         System.out.println("helloworld");
      }
   } 
}

while循环

格式

while(判断条件){ 
  循环体;
  控制条件;
}

执行流程：
根据初始值和判断条件进行比较，如果比较的结果是true执行循环体，执行控制条件改变初始化值，拿着改变的值再和判断条件进行比较，如果比较的结果是true重复上述操作直到比较的结果是 false才结束循环。
例

class WhileDemo{ 
  public static void main(String[] args) {
    //房价
    int price=6000*100;//首付
    //4400 int money=0;
    //计数
    int count=0;
    while(money<price){ money+=4400;
      count++;
    }
    System.out.println(count*1.0/12);
 }
}

do…while循环

格式

do{
 循环体;
 控制条件;
}while(判断条件);

执行流程：
先获取初始化值接着执行循环体接着执行控制条件改变初始值，拿着改变的初始值和判断条件进行比较，如果比较的结果是true执行循环体执行控制条件改变初始值拿着改变的初始值和判断条件进行比较如果比较的结果是true重复上述操作直到比较的结果为false结束循环。
例

class DoWhileDemo{
  public static void main(String[] args) {
  //打印10遍helloworld int i=1; 
  do{
    System.out.println("helloworld"); //i++;
  }while(i<=10);
  }
}

区别与联系

1.三种循环等效转换
2.for循环的初始值不能在后续使用
3.三种循环都有可能出现死循环

控制跳转的语句

break

在switch中用作结束语句 在循环中当作结束当前循环

continue

在循环中当作跳过当次循环

return（方法）

返回一个值

数组

概念

存储多个相同类型元素的容器

定义

1.数据类型[] 数组名=new 数据类型[数组长度/元素个数];
int[] arr=new int[3];//定义出长度为3的整型数组arr(指定长度) 支持分为声明和初始化两个过程通过数组得地址值可以找到对应的数组容器，数组内部自动对存储的元素进行编号（从0开始），通过数组地址值和元素编号就可以唯一确定数组中的元素—数组名[编号]（编号—下标）
2.数据类型[] 数组名=new 数据类型[]{元素值1,元素值2,…};
给定元素值，长度已经确定，前面不能在指定长度值支持分为声明和初始化两个过程
3.数据类型[] 数组名={元素值1,元素值2,…};
int[] arr={1,2,3};//给定元素值，长度已经确定

/*
数组的定义格式
*/
class ArrayDemo{ 
  public static void main(String[] args) {
    //1.定义格式
    int[] arr=new int[2];
    //给数组的第二个元素进行赋值 arr[1]=10;
    //声明
    int[] arr1;
    //初始化
    arr1=new int[3];
    //输出数组名---数组地址值
    System.out.println(arr);
    //输出数组的第二个元素的值
    System.out.println(arr[1]);
    //2.定义格式
    int[] arr=new int[]{1,2,3};
    //声明
    int[] arr1;
    //初始化
    arr1=new int[]{3,5};
    //3.定义格式
    //底层会自动开辟空间可以存储数据
    int[] arr={1,2,3};
    //声明
    int[] arr1;
    //初始化
    //底层没有开辟空间所以不能存储数据 arr1={5,6};
}
}

Java内存分区

栈
存储变量（暂时），栈中存储的数据使用完毕时立刻销毁
堆
存储对象，存储的对象如果不再使用会在某个是时刻通过系统进行
系统默认初始值
（byte、short、int—0）、(char—’\u0000’ \u代表编码使用的码表是 utf-16)、(long—0L)、（float—0.0F）、（double—0.0）、（boolean—false）、（所有引用类数据型—null）

数组的应用

遍历
依次输出数组元素值 数组名[下标]—确定任意数组元素

/*
数组遍历
*/
import java.util.Arrays; 
class ArrayBianLiDemo{ 
   public static void main(String[] args) {
   //给定数组
   int[] arr={1,7,9,3,6,2};
   //通过普通for循环遍历数组元素
   //数组长度---数组名.length
   for(int i=0;i<arr.length;i++){
    System.out.println(arr[i]); 
    arr[i]+=2;
    }
   //增强for循环
   //(元素类型变量名:遍历的数组的名称)
   //把数组元素的值拷贝到变量身上
   for(int i:arr){
   System.out.println(i);
   }*/
   //自动把数组元素内容进行拼接，拼接成一个字符串输出（展示结果）
   System.out.println(Arrays.toString(arr));
}
}

最值
求出数组元素中的最大值/小值

/*
最值
*/
class ArrayMax{ 
  public static void main(String[] args) {   
    int[] arr={3,5,7,2,9,1};
    //提供参照物---默认选第一个元素
    int max=arr[0];
    //for循环---依次比较
    for(int i=1;i<arr.length;i++){
    //和所有的元素进行比较
    if(max<arr[i]){
    //把较大的元素值赋值给max
    max=arr[i];
}
}
    System.out.println(max);
}
}

查找
指定一个数，根据这个数返回第一次出现的数组元素的下标二分查找

/*
查找
*/
class ArraySearchDemo{
  public static void main(String[] args) {
  //给定数组
  //int[] arr={4,2,7,1,8,9};//无序
  int[] arr={1,2,4,5,6,7,9};//有序  任意连续区域都是有序的
  //给定查找数
  int num=1;
  //通过普通for循环依次遍历数组元素进行查找
  /*for(int i=0;i<arr.length;i++){
  //判断比较
  if(num==arr[i]){
  System.out.println(i);
  break;
  }
  }*/
  /*int count=0;
  //通过增强for循环和计数变量 for(int i:arr){
  //count++;//1 2 3 4
  if(i==num){
  System.out.println(count);
  break;
  }
  count++;//1 2 3
  }*/
  //二分（折半）查找---二分算法在查找的应用
  //定义三个下标用变量来表示
  int min=0;
  int max=arr.length-1;//长度值-1 int mid=(min+max)/2;
  //循环--while
  while(num!=arr[mid]){//中间下标对应的元素值不相等才进循环操作
  //如果查找数大于中间下标对应的元素值
  if(num>arr[mid]){
  //把最下下标往右挪动
  min=mid+1;
  }
  //如果查找数小于中间下标对应的元素值
  if(num<arr[mid]){
  //把最大下标往左挪动
  max=mid-1;
  }
  //查找数不存在情况
  if(min>max){
  System.out.println("查无此数"); break;
  }
  //重新计算中间下标 mid=(min+max)/2;
  } 
  if(max>=min)
  System.out.println(mid);
  }
}

排序

/*
冒泡排序
*/
public class BubbleSort {
    public static void main(String[] args) {
        //定义一个待处理数组
        int[] arr = {2,1,6,3,7,4,3,0,9,8};
//定义中间变量，用于后面的元素交换
        int invar = 0;
        for (int i = 0; i <arr.length-1 ; i++) {
            if (arr[i]>arr[i+1]){
//交换顺序
                invar = arr[i+1];
                arr[i+1] = arr[i];
                arr[i] = invar;
            }
//打印每次的交换结果
        System.out.println(Arrays.toString(arr));
        }
    }
}

扩容
扩大/小数组容器的容量（长度）—数组复制实现
注意：数组定义完成之后长度无法改变

/*
数组扩容
*/
import java.util.Arrays;
class ArrayKuoDemo{
    public static void main(String[] args) { 
      //给定原数组 
      int[] arr1={1,3,4,6,2};//{1,3,4,6,2,0,0,0,0,0} 
      //数组的扩容
      //使用不方便但是复制元素内容比较灵活 
      //新数组
      /*int[] arr2=new int[arr1.length*2];//确定新长度 
      //数组的复制(原数组,拷贝的起始下标,目标数组,粘贴的起始下标,复制的元素个数)
      System.arraycopy(arr1,0,arr2,0,arr1.length); 
      //数组地址值的赋值 
      arr1=arr2;*/
      //使用方便但是复制元素内容不灵活 
      //底层由上述三步实现 
      //(原数组,新长度) 
      arr1=Arrays.copyOf(arr1,arr1.length-1);
      System.out.println(Arrays.toString(arr1));
    }
}

二维数组

存储的数组元素是一维数组的数组
定义格式

1.数据类型[][] 数组名=new 数据类型[二维数组长度][一维数组长度];

2.数据类型[][] 数组名=new 数据类型[二维数组长度][];

3.数据类型[][] 数组名={{元素值1,元素值2,…},{元素值1,元素值2,…},{元素值1,元素值2，…},…};