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. 将textField编辑完内容作为参数发送请求

    将textField编辑完内容作为参数发送请求  首先赋值默认值  其次把编辑完的内容传给model,这样的话,model里面的数据就是编辑完之后的内容了

  2. Solve Error Debug Assertion Failed Expression vector iterators incompatible Using PCL in Release Mode of VS2010

    When using PCL 1.4.0 in the release mode building under VS2010, we might sometime get the error &quo ...

  3. kvm安装

    基础环境: 192.168.1.67                  super67 硬件cpu需要支持:Intel VT-x 技术 本实验使用虚拟机VMware Workstation上的虚拟机 ...

  4. Scala：使用Sublime开发Scala

    Scala:使用Sublime开发Scala 第一步:[Tools][Build System][New Build System] 第二步:在打开的新文件中输入: { //"cmd&quo ...

  5. mac使用指南：brew的安装

    官网 http://brew.sh/ 安装并且下载brew /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/ ...

  6. Scrum会议10(Beta版本) 补交

    组名:天天向上 组长:王森 组员:张政.张金生.林莉.胡丽娜 代码地址:HTTPS:https://git.coding.net/jx8zjs/llk.git SSH:git@git.coding.n ...

  7. jpush极光推送知识点总结

    1.jpushClient.sendPush(pushpayLoad):是发送推送的主要方法 2.pushpayload是具体推送消息.推送对象范围的封装 3.jpushClient.sendPush ...

  8. ecshop lang用法

    ecshop lang用法 分类: ECSHOP2013-08-15 16:17 2184人阅读 评论(0) 收藏 举报 ecshop目录下的languages目录．这个是ecshop语言包所在.ec ...

  9. PIVOT 用于将列值旋转为列名

    PIVOT 用于将列值旋转为列名(即行转列),在 SQL Server 2000可以用聚合函数配合CASE语句实现 PIVOT 的一般语法是:PIVOT(聚合函数(列) FOR 列 in (…) )A ...

  10. javaWeb中servlet开发(2)——servlet与表单

    1.重写doGet方法 public class InputServlet extends HttpServlet{ public void doGet(HttpServletRequest req, ...