day05-java-（循环问题，数组）　　　　

1.三种循环结构的更佳适用情况:
  1)while: "当..."循环
  2)do...while: "直到..."循环
                要素1与要素3相同时首选
  3)for:固定次数循环

循环结构的选择:
1.先看固定次数还是不固定次数:
    固定次数-----首选for
    不固定次数-----再看要素1与3是否相同
        要素1与要素3相同时-----首选do...while
        要素1与要素3不同时-----首选while

2.嵌套循环:
  1)循环中套循环，一般多行多列时使用，外层控制行，内层控制列
  2)执行过程:外层循环走一次，内层循环走所有次
  3)建议:循环层数越少越好，能用一层就不用两层，能用两层就不用三层
         若需求必须要通过三层以上循环才能解决，说明设计有问题
  4)break只能跳出一层循环

3.程序=算法+数据结构
  1)算法:解决问题的流程/步骤(顺序、分支、循环)
  2)数据结构:将数据按照某种特定的结构来保存
             数怎么存
    设计良好的数据结构会导致好的算法

4.数组:
  1)相同数据类型元素的集合
  2)数组是一种数据类型(引用类型)
  3)数组的定义:
      int[] arr = new int[4];
  4)数组的初始化:
      int[] arr = new int[4]; //0,0,0,0
      int[] arr = {1,3,5,7};  //1,3,5,7
      int[] arr = new int[]{1,3,5,7}; //1,3,5,7
      int[] arr;
      arr = {1,3,5,7}; //编译错误
      arr = new int[]{1,3,5,7}; //正确
      
    //声明浮点型数组d，包含8个元素
    //每个元素都是double型，默认值为0.0
    double[] d = new double[8];

//声明布尔型数组b，包含26个元素
    //每个元素都是boolean型，默认值为false
    boolean[] b = new boolean[26];

//声明整型数组a，包含4个元素
    //每个元素都是int类型，默认值为0
    int[] a = new int[4]; //0,0,0,0
    
  5)数组的访问:
    5.1)通过(数组名.length)可以获取数组的长度
          int[] arr = new int[4];
          System.out.println(arr.length); //4
    5.2)通过下标/索引来访问数组中的元素
        下标从0开始，最大到(数组的长度-1)
          int[] arr = new int[3];
          arr[0] = 100; //给arr中第1个元素赋值为100
          arr[1] = 200; //给arr中第2个元素赋值为200
          arr[2] = 300; //给arr中第3个元素赋值为300
          arr[3] = 400; //数组下标越界异常
          System.out.println(arr[arr.length-1]); //输出最后一个元素的值

6)数组的遍历:
      int[] arr = new int[10];
      for(int i=0;i<arr.length;i++){
        arr[i] = 100;
      }
      for(int i=0;i<arr.length;i++){
        System.out.println(arr[i]);
      }
      for(int i=arr.length-1;i>=0;i--){
        System.out.println(arr[i]);
      }

7)数组的复制:
    7.1)System.arraycopy(a,1,a1,0,4);
    7.2)int[] a1 = Arrays.copyOf(a,6);
        a = Arrays.copyOf(a,a.length+1); //扩容
        a = Arrays.copyOf(a,a.length-1); //缩容

8)数组的排序:
    8.1)Arrays.sort(arr); //升序
    8.2)冒泡原理:
        8.2.1)四个数冒3轮
        8.2.2)每一轮都是从第1个元素开始冒
              每一次都和它的下一个元素比
        8.2.3)冒出来的就不带它玩了

9)计算程序执行时间：
    long a = System.currentTimeMillis();
    Arrays.sort(arr);
    long b = System.currentTimeMillis();

System.out.println(b-a); //排序消耗的毫秒数

冒泡排序执行过程：
int[] arr = {45,8,34,1}; //升序
第一轮:
  45和8比，换，8,45,34,1
  45和34比，换，8,34,45,1
  45和1比，换，8,34,1,45-------45冒出来了
第二轮:
  8和34比，不换
  34和1比，换，8,1,34,45-------34冒出来了
第三轮:
  8和1比，换，1,8,34,45--------8冒出来了

找最大值算法:

int[] arr = {23,45,67,10};
1)假设第1个元素最大
    int max = arr[0];
2)遍历剩余元素，将剩余元素与max对比，
  若剩余元素大于max，则修改max的值为较大的
    for(int i=1;i<arr.length;i++){
      if(arr[i]>max){
        max = arr[i];
      }
    }
max=23/45/67

数组操作代码演示：

package day05;

import java.util.Arrays;

//数组的演示

public class ArrayDemo {

    public static void main(String[] args) {

        //6.数组的排序

        int[] arr = {23,56,4,57,24,1,7,9};

        Arrays.sort(arr); //对arr升序

        for(int i=0;i<arr.length;i++){

            System.out.println(arr[i]);

        }

        /*

        //5.数组的复制

        int[] a = {10,20,30,40,50};

        //数组的扩容(创建一个新的数组)

        a = Arrays.copyOf(a,a.length+1);

        for(int i=0;i<a.length;i++){

            System.out.println(a[i]);

        }

        */

        /*

        int[] a = {10,20,30,40,50};

        //a:源数组

        //a1:目标数组

        //6:目标数组的长度

        int[] a1 = Arrays.copyOf(a,4);

        for(int i=0;i<a1.length;i++){

            System.out.println(a1[i]);

        }

        */

        /*

        int[] a = {10,20,30,40,50};

        int[] a1 = new int[6];

        //a:源数组

        //1:源数组的起始下标

        //a1:目标数组

        //0:目标数组的起始下标

        //4:复制的元素个数

        System.arraycopy(a,1,a1,0,4);

        for(int i=0;i<a1.length;i++){

            System.out.println(a1[i]);

        }

        */

        /*

        //4.数组的遍历

        int[] arr = new int[10];

        for(int i=0;i<arr.length;i++){

            arr[i] = (int)(Math.random()*100);

        }

        for(int i=0;i<arr.length;i++){

            System.out.println(arr[i]);

        }

        */

        /*

        //3.数组的访问

        int[] arr = new int[3];

        System.out.println(arr.length); //3.

        arr[0] = 100; //给arr中第1个元素赋值为100

        arr[1] = 200;

        arr[2] = 300;

        //arr[3] = 400; //数组下标越界异常

        System.out.println(arr[arr.length-1]); //300

        */

        /*

        //2.数组的初始化

        int[] arr = new int[4]; //0,0,0,0

        int[] arr1 = {1,4,6,8}; //1,4,6,8

        int[] arr2 = new int[]{1,4,6,8}; //1,4,6,8

        int[] arr3;

        //arr3 = {1,4,6,8}; //编译错误

        arr3 = new int[]{1,4,6,8}; //正确

        */

        /*

        //1.数组的定义

        //声明整型数组arr，包含10个元素，每个元素都是int类型，默认值为0

        int[] arr = new int[10];

        */

    }

}

求数组元素的最大值

package day05;

import java.util.Arrays;

//求数组元素的最大值

public class MaxOfArray {

    public static void main(String[] args) {

        //给arr赋值

        int[] arr = new int[10];

        for(int i=0;i<arr.length;i++){

            arr[i] = (int)(Math.random()*100);

            System.out.println(arr[i]);

        }

        //找arr中的最大值

        int max = arr[0]; //假设第1个元素最大

        for(int i=1;i<arr.length;i++){ //遍历剩余元素

            if(arr[i]>max){ //若剩余元素大于max

                max=arr[i]; //修改max的值为较大的

            }

        }

        System.out.println("最大值为:"+max);

        //扩容

        arr = Arrays.copyOf(arr,arr.length+1);

        //将最大值赋值给arr中的最后一个元素

        arr[arr.length-1] = max;

        for(int i=0;i<arr.length;i++){

            System.out.println(arr[i]);

        }

    }

}
九九乘法表
package day05;

//九九乘法表

public class MultiTable {

    public static void main(String[] args) {

        for(int num=1;num<=9;num++){ //控制行

            for(int i=1;i<=num;i++){ //控制列

                System.out.print(i+"*"+num+"="+i*num+"\t");

            }

            System.out.println(); //换行

        }

        /*

         * num=4

         *   ......

         * num=3

         *   i=1 1*3=3

         *   i=2 2*3=6

         *   i=3 3*3=9

         *   i=4

         *   换行

         * num=2

         *   i=1 1*2=2

         *   i=2 2*2=4

         *   i=3

         *   换行

         * num=1

         *   i=1 1*1=1

         *   i=2

         *   换行

         */

    }

}

冒泡排序算法

package day05;

//冒泡排序算法

public class BubbleSort {

    public static void main(String[] args) {

        /*

         * 要求:

         * 1.声明整型数组arr包含10个元素，

         *   每个元素为0到99之间的随机数，

         *   输出每个元素的值

         * 2.冒泡方式对arr进行升序排列

         * 3.输出arr排序后的数据

         */

        int[] arr = new int[10];

        for(int i=0;i<arr.length;i++){

            arr[i] = (int)(Math.random()*100);

            System.out.println(arr[i]);

        }

        for(int i=0;i<arr.length-1;i++){ //控制轮数

            for(int j=0;j<arr.length-1-i;j++){ //控制次数

                if(arr[j]<arr[j+1]){ //每次都是和它的下一个元素比

                    int t = arr[j]; //满足条件则交换

                    arr[j] = arr[j+1];

                    arr[j+1] = t;

                }

                //若前数大于后数则交换，保证前数小于后数(升序)

                //若前数小于后数则交换，保证前数大于后数(降序)

            }

        }

        System.out.println("排序后:");

        for(int i=0;i<arr.length;i++){

            System.out.println(arr[i]);

        }

    }

}

课后作业：

判断一个数字是否是质数：

方法一，判断？是否为质数：

package day06;

public class Test01 {

    public static void main(String[] args) {

        int num = 1;

        boolean flag = true; //1.假设是质数

        //for(int i=2;i<num;i++){ //2/3/4/.../98/99

        //for(int i=2;i<=num/2;i++){ //2/3/4/.../49/50

        for(int i=2;i<=Math.sqrt(num);i++){ //2/3/4/.../9/10

            if(num%i==0){

                flag = false; //2.修改为不是质数

                break;

            }

        }

        if(flag){ //3.判断得结论 相当于if(flag==true){

            System.out.println(num+"是质数");

        }else{

            System.out.println(num+"不是质数");

        }

    }

}

方法二，判断0~100之间的质数：

package day06;

import java.util.Scanner;

public class Test01 {

    public static void main(String[] args) {

        int count = 0; //质数的个数

        for(int num=2;num<=100;num++){

            boolean flag = true;

            for(int i=2;i<=Math.sqrt(num);i++){ //2/3/4/.../9/10

                if(num%i==0){

                    flag = false;

                    break;

                }

            }

            if(flag){

                count++; //质数个数增1

                System.out.print(num+"\t");

                if(count%10==0){

                    System.out.println();

                }

            }

        }

    }

}

方法三，判断2~？之间哪些是质数：

package day06;

import java.util.Scanner;

public class Test01 {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入查找质数的范围：2~");

        int max = scanner.nextInt();

        scanner.close();

        int numOfPrime = 0;

        for (int n = 2; n <= max; n++) {

            // 判断n是否是质数

            int m = (int) Math.sqrt(n);

            int i = 2;

            for (; i <= m; i++) {

                if (n % i == 0)

                    break;

            }

            if (i > m) {

                System.out.print(n + " ");

                if (++numOfPrime % 10 == 0)

                    System.out.println();

            }

        }

        System.out.println("\n共有" + numOfPrime + "个质数");

    }

}

求0~99之间的10个随机数，进行排序，并求出最小数为？

方法一：

package day06;

import java.util.Scanner;

public class Test01 {

    public static void main(String[] args) {

        int[] arr = new int[10];

        for(int i=0;i<arr.length;i++){

            arr[i] = (int)(Math.random()*100);

            System.out.println(arr[i]);

        }

        int min = arr[0];

        for(int i=1;i<arr.length;i++){

            if(arr[i]<min){

                min=arr[i];

            }

        }

        System.out.println("最小值为:"+min);

        int[] arr1 = new int[arr.length+1];

        System.arraycopy(arr,0,arr1,1,arr.length);

        arr1[0] = min;

        for(int i=0;i<arr1.length;i++){

            System.out.println(arr1[i]);

        }

    }

}

方法二：

package day06;

import java.util.Random;

import java.util.Arrays;

public class Test01 {

    public static void main(String[] args) {

        //创建一个 10 个长度的数组

        int[] arr = new int[10];

        //随机生成 10 个0－99之间的数值，放入数组

        Random ran = new Random();

        for(int i=0;i<arr.length;i++){

            arr[i] = ran.nextInt(100);

        }

        //打印数组中的数据

        System.out.println("数组中的数据为：" + Arrays.toString(arr));

        //查询最小值

        int min = arr[0];

        for(int i=1; i<arr.length; i++) {

            if(min > arr[i]) {

                min = arr[i];

            }

        }

        System.out.println("最小值是：" + min);

        //创建新数组

        int[] arrNew = new int[arr.length + 1];

        //将原数组的元素拷贝进入新数组

        System.arraycopy(arr, 0, arrNew, 1, arrNew.length-1);

        //最小值放入新数组第一位，并打印新数组

        arrNew[0] = min;

        System.out.println("新数组中的数据为：" + Arrays.toString(arrNew));

    }

}

day05-java-（循环问题，数组）的更多相关文章

  1. day05<Java语言基础--数组>

    Java语言基础(数组概述和定义格式说明) Java语言基础(数组的初始化动态初始化) Java语言基础(Java中的内存分配以及栈和堆的区别) Java语言基础(数组的内存图解1一个数组) Java ...

  2. java循环、数组练习

    System.out.println("请输入学生个数"); int a=sc.nextInt();//定义一个变量说明学生的数量 int max=0; int[] scores= ...

  3. Java循环和数组练习题：打印素数升级版

    前两天一个小伙伴问了我一个数组的练习题,我一看思路很清晰,就是打印素数加了个数组.没想到写的时候啪啪打脸,终究还是没逃过眼高手低.本来不打算发出来了,因为发出来愈发显得我很菜,最后还是打算分享出来,一 ...

  4. Java基础：数组的声明，循环，赋值，拷贝。

    数组的声明 一般有两种形式的声明: int[] a; int a[]; 这两种声明都没错,但是大多数都使用第一种声明,因为变量名是独立的,不带任何符号. 声明一个数组,并没有将a真正的初始化为一个数组 ...

  5. IT兄弟连 Java语法教程 数组 使用foreach循环遍历数组元素

    从JDK5之后,Java提供了一种更简单的循环:foreach循环,也叫作增强for循环,这种循环遍历数组和集合更加简洁.使用foreach循环遍历数组和集合元素时,无需获得数组或集合的长度,无需根据 ...

  6. Java中的数组

    1,可以创建自己的类的数组,但是自己的类必须实现get()和put函数 2,声明数组:int[] arrayOfInt.注意,定义数组时不可以指定大小 3,创建与初始化:通过new.arrayOfIn ...

  7. java学习之数组（二）

    在上一节中我们讲到了数组的概念,定义,以及在内存当中的表现形式.那么这里我们来说一下,数组的另一种定义方式. 在上一篇当中我们规定是这个样子定义数组的, class ArrDemo { public ...

  8. 【JAVA零基础入门系列】Day10 Java中的数组

    什么是数组?顾名思义,就是数据的组合,把一些相同类型的数放到一组里去. 那为什么要用数组呢?比如需要统计全班同学的成绩的时候,如果给班上50个同学的成绩信息都命名一个变量进行存储,显然不方便,而且在做 ...

  9. Java基础之数组(一)

    数组的定义 数组是相同类型数据的有序集合.数组描述的是相同类型的若干个数据,按照 一定的先后次序排列组合而成.其中,每一个数据称作一个元素,每个元素可以通过一个索引(下标)来访问它们.数组的三个基本特 ...

  10. 第81节：Java中的数组

    第81节:Java中的数组 本节介绍数组的基本概念,数据就是一种数据结构,可以用来存储多个数据,每个数组中可以存放相同类型的数据.比如,在学校,我们是一个班,这里的班级中每个同学都是这个班级数组中的元 ...

随机推荐

  1. jstl fn标签

    JSTL使用表达式来简化页面的代码,这对一些标准的方法,例如bean的getter/setter方法,请 求参数或者context以及session中的数据的访问非常方便,但是我们在实际应用中经常需要 ...

  2. Qt5.4 VS2010 Additional Dependancies

    Go to Linker -> General -> Additional LIbrary Directories: qtmaind.libQt5Cored.libQt5Guid.libQ ...

  3. [APAC]导入图片至Word,然后按规则命名(2/2)

    #将所有docx文件改成可读 Set-ItemProperty -Path "e:\screenshot\*.docx" -Name IsReadOnly -Value $fals ...

  4. [排错] PATH_MISSING

    症状: 更换了磁带机部件,导致Robots选项卡中的TLD(2) Robotic Path显示为PATH_MISSING. 解决方法: 概括起来就是: 删除TLD(2),重新创建Robot记录,然后重 ...

  5. IE6 BUG 汇总

    1.IE6双倍边距bug 当页面内有多个连续浮动时,如本页的图标列表是采用左浮动,此时设置li的左侧margin值时,在最左侧呈现双倍情况.如外边距设置为10px, 而左侧则呈现出20px,解决它的方 ...

  6. Java学习资源

    Java技术路线图 指路明灯 一位资深程序员大牛给予Java初学者的学习路线建议 Java源码阅读的真实体会 概要 JDK发展历程 Java项目经验 基于java平台的常用资源 官方文档 Java™ ...

  7. var object dynamic的区别

    一.var var本身不是一种类型,只是一种语法糖:var声明的变量在赋值的时候即已决定其变量类型,编译时会进行校验. 二.object object是所以类型的基类,故可以赋任何类型的值. 三.dy ...

  8. 简单排序算法 C++类实现

    简单排序算法: 冒泡排序 插入排序 选择排序 .h代码: // // SortClass.h // sort and selection // // Created by wasdns on 16/1 ...

  9. THinkPHP在模板中的volist循环使用外部变量注意事项

    循环中.自己定义的id=volist就可以使用$volist.id 或者$volist['id'] 而外面定义的变量就不能使用$vo.id 必须使用$vo['id']<volist name=& ...

  10. Web交互设计优化的简易check list

    Web交互设计优化的简易check list 00 | 时间: 2011-02-11 | 28,842 Views 交互设计, 用户研究   “优化已有产品的体验”,这是用户体验相关岗位职责中常见的描 ...