1.循环的使用
1.1do…while循环
do…while语法规则：
语句0 ;
do{
语句1;//循环体
语句2;//
}while (循环条件);
语句3 ;
import java.util.Random;
import java.util.Scanner;
// do ... while : 先做一次，然后判断是否需要继续做下一次。
// do { // 循环体} while {};
public class DoWhile {
public static void main(String[] args) {
// 让用户输入数据。判断输入的数据，如果不是30，就继续输，如果是30，就结束循环
Scanner scanner = new Scanner(System.in);
int data;
do{
System.out.println("请输入一个整数");
data = scanner.nextInt();
}while(data !=30);
Random random = new Random();
// 练习： 产生一个随机整数1~100的， 如果这个数 能同时被3，和 7整除，就输出符合条件的
// 这个数据。
int n;
do {
n = random.nextInt(100)+1;
if (n % 3 == 0 && n % 7== 0){
break;
}
}while (true);
System.out.println(n);
}
}
1.2循环结构—while/do…while流程对比
1.3循环结构——死循环
循环没有指明结束条件的情况会造成死循环
public static void main(String[] args) throws Exception {
// 练习： 每隔1秒输出时间
// 因为使用的直接量“true”，程序在编译的时候就知道是死循环，检查到后续的代码没有机会被执行到；
boolean flag = true;
while (flag) {
Date date = new Date();// 年月日时分秒
System.out.println(date);
Thread.sleep(1000);// 等待1000毫秒
}
// 死循环
int i = 0; // 21亿 溢出
for(;i >=0; i++){
System.out.println(i);
}
}
1.4嵌套循环
外层走一次，内层走所有次
建议循环层数越少越好
// 输出2-100之间的质数,保存到数组中
public class Demo3 {
public static void main(String[] args) {
for(int num = 2; num <= 100; num++) {// 循环判断2~100之间的每个数据
// 使用数据从开始。逐渐和自己的平方根开始取余运算，如果没有能被整除的，说明是质数
boolean flag = true; // 用于标识是否为质数： true质数， false 不是质数
for(int j = 2; j <= Math.sqrt(num); j++) {
if( num % j == 0 ) {
flag = false;
break; // 只要有一个能被整除的，就说明不是质数了，就提前结束这个循环的运行。
}
}
if( flag ) { // 内层循环结束，还没有把flag修改为false， 说明i是质数
System.out.println(num + "是质数。");
}
}
}
}
1.5冒泡排序
所谓的冒泡算法就是从左往右依次比较两个数大小，若前一个数大于后一个数，则两个数交换位置
import java.util.Arrays;
import java.util.Random;
// 冒泡排序
public class Demo4 {
public static void main(String[] args) {
// 创建一个整数数组，随机赋值，然后对这个数组，升序排序。
Random random = new Random();
int[] arr = new int[6];
for (int i = 0; i < 6; i++) {
arr[i] = random.nextInt(50)+1;
}
System.out.print("原数组："+Arrays.toString(arr));
// 升序
int temp;
for(int i = 0 ; i < arr.length-1; i++){// 只比较长度-1次
for(int j = 0; j < arr.length-1-i ; j++){// 前面i个数已经升序，不用在比较 （后面的排好序的元素，不用重复排了）
if(arr[j] > arr[j+1]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
System.out.print("\n"+"排序后："+Arrays.toString(arr));
}
}
2.数组的使用
程序=算法+数据结构，
算法：解决问题的步骤，或者叫流程（顺序，分支，循环）
数据结构：将数据按照某种特定的结构保存。
数组是一种最基本的数据结构。
2.1什么是数组
-
数组：相同数据类型的元素组成的集合
-
元素按线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素； 除最
后一个元素外，每一个元素都有唯一的后继元素（“一个跟一个”）,可以通过元素所在位置的顺序号
（下标）做标识来访问每一个元素（下标从0开始，最大到元素的个数-1）
2.2数组的声明
-
声明数组的语法：
数据类型[] 数组名 = new 数据类型[大小]；
-
数组声明的要点
-
-确切的数据类型
-
-整体的数组名字
-
-不能缺少的“[]”
-
-执行new语句才使得数组分配到了指定大小的空间
-
-int[] arr 与 int arr[]两种写法均可
-
-申明数组时不规定数组长度，new关键字分配空间时需要指定分配的空间大小
-
-
数组初始化
数组的初始化主要有以下3种：
eg：
int[ ] arr = new int[ 3 ];
int[ ] arr = {1,2,3,4};
int[] arr = new int[ ]{1,2,3,4};1.定义的时候初始化
int[] arr = new int[4];
int[] arr = {1,4,7};
int[] arr = new int[]{2,4,6,8}2.定义之后再初始化
int[] arr;
arr = new int[5];
arr = new int[]{1,2,3}//正确
arr= {1,4,6};//错误3.数组声明的默认值
数组new之后，每个元素都有默认值。int,long默认值为0，double默认值为0.0，
boolean默认值为false,char默认值为空字符。
import java.util.Arrays;
public class ArrayDemo {
public static void main(String[] args) {
int[] a1 = {1,2,3,4,5,6}; // 表示元素是整数的数组，数组长度是6
// int[] a2 = new int[]; // 编译错误： 没有指定数据的长度
int[] a2 = new int[]{1,2,3}; // 表示元素是整数的数组，数组长度是3
int[] a3 = new int[4]; // 表示元素是整数的数组，数组长度是4，并且初始化值都是0
// 先定义，在初始化
int[] a4;
// a4 = {1,2,3,4}; // 编译错误： ***如果先定义了引用，再赋值，不能使用{}的方式
a4 = new int[]{1,2,3,4,5}; //
a4 = new int[8];// 没有给元素赋值，元素默认值是0 [0, 0, 0, 0, 0, 0, 0, 0]
// 数组的默认值
System.out.println("a4: " + Arrays.toString(a4));
char[] a5 = new char[6]; // [ , , , , , ]
System.out.println("a5: " + Arrays.toString(a5));
String[] a6 = new String[6]; // [null, null, null, null, null, null]
System.out.println("a6: " + Arrays.toString(a6));
double[] a7 = new double[6]; // [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
System.out.println("a7: " + Arrays.toString(a7));
boolean[] a8 = new boolean[6]; // [false, false, false, false, false, false]
System.out.println("a8: " + Arrays.toString(a8));
}
}
2.3数组访问
- 获取数组的长度
int[] arr = {1,3,5} ;
int len = arr.length; //3
- 通过下标访问数组
arr[0]=20,arr[1]=30,arr[2]=40;
- 数组的遍历（正序或逆序）
import java.util.Arrays;
public class ArrayDemo2 {
public static void main(String[] args) {
// 产生'A' ~ 'Z'的字符,然后随机找出一个字符
char[] cs = new char[26];
for(int i =0; i < cs.length; i++) {
cs[i] = (char)('A' + i);
}
System.out.println(Arrays.toString(cs));
int index = (int)(Math.random() * 26);
System.out.println("随机字符：" + cs[index]);
}
}
2.4数组复制
- JDK提供对数组进行复制的方法，即将一个数组（源数组）中的各个元素值复制到另一个数组（目标数组）中：
import java.util.Arrays;
// 数组的复制: 指定从某个数组的位置开始，复制数据，把复制的数据放到另一个数组中的某个位置，并且设置需要复制的个数
// *** 数组的复制，并没有产生新的数组。主要是修改了数组中的元素。
public class ArrayCopyDemo {
public static void main(String[] args) {
int [] arr = {1, 2,3,4,5,6,7,8,9,10};
// 希望把arr的前五个元素放在arr1数组中，后五个元素放在arr2中
int[] arr1 = new int[arr.length / 2];
int[] arr2 = new int [arr.length / 2];
System.arraycopy(arr, 0, arr1, 0, arr.length/2);
System.arraycopy(arr, 5, arr2, 0, arr.length/2);
// System.out.println("arr1: " + Arrays.toString(arr1));
// // System.out.println("arr2: " + Arrays.toString(arr2));
// ** 自己写循环完成
for(int i = 0; i < arr.length; i++) {
if (i <= (arr.length-1)/2){
arr1[i] = arr[i];
}else {
arr2[i - arr.length/2] = arr[i];
}
}
// System.out.println("arr1: " + Arrays.toString(arr1));
// System.out.println("arr2: " + Arrays.toString(arr2));
// 练习： 把4~9， 复制给arr3；
int[] arr3 = new int[6];
// System.arraycopy(arr, 3, arr3, 0, arr3.length);
// System.out.println("arr3: " + Arrays.toString(arr3));
// 练习： arr4 = {1,2,3,0,0,0,0,0} .. 把arr中的4,5,6,7复制到arr4中的下标为3开始的地方
int[] arr4 = {1,2,3,0,0,0,0,0};
System.arraycopy(arr, 3, arr4, 3, 4);
System.out.println("arr4: " + Arrays.toString(arr4));
}
}
2.5数组扩容
- 数组的长度在创建后不可以改变的。所谓“扩展”是指创建一个更大新数组，并将原有数组的内容复制到其中。
- Jdk提供了一个方法，Arrays.copyOf 可以实现数组的“扩容
package Day5;
import java.util.Arrays;
// 数组扩容
// 输出2-100之间的质数，保存到数组中
public class ArrayCopyDemo1 {
public static void main(String[] args) {
int[] arr = new int[0]; // 不知道质数的个数。找到一个质数，需要保存到数组中，我们就数组长度+1
for(int num = 2; num <= 100; num++) {// 循环判断2~100之间的每个数据
// 使用数据从2开始。逐渐和自己的平方根开始取余运算，如果没有能被整除的，说明是质数
boolean flag = true; // 用于标识是否为质数： true质数， false 不是质数
for(int j = 2; j <= Math.sqrt(num); j++) {
if( num % j == 0 ) {
flag = false;
break; // 只要有一个能被整除的，就说明不是质数了，就提前结束这个循环的运行。
}
}
if( flag ) { // 内层循环结束，还没有把flag修改为false， 说明i是质数
arr = Arrays.copyOf(arr, arr.length+1);
arr[arr.length-1] = num;
}
}
System.out.println( "所有质数：" + Arrays.toString(arr));
}
}
2.6数组排序
-
自定义排序方法：比如冒泡排序
-
jdk种的Arrays.sort方法的使用
package Day5;
import java.util.Arrays;
// 排序
// Arrays.sort() -- jdk提供的排序方法
public class SortDemo {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5, 6, 7, 8};
// arr = bubbleSort(arr);
// System.out.println(Arrays.toString(arr));
Arrays.sort(arr); // 排序
System.out.println(Arrays.toString(arr));
String[] strs = {"tom", "jack", "jerry", "rose","hanmeimei","小红"};
Arrays.sort(strs); // 单词首字母的编码排序，如果首字母相同，就第二个....
System.out.println("strs:"+Arrays.toString(strs));// [hanmeimei, jack, jerry, rose, tom, 小红]
}
public static int[] bubbleSort(int[] arr) {
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 temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
return arr;
}
}
扫一扫
3523
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
