Java（day05）while循环和数组

while循环 

while常用做死循环，循环条件写true,但需要设置出口break

package cn.tedu.basic;

import java.util.Random;
import java.util.Scanner;


//本类用于练习while循环
public class TestWhile {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int r=creatNum();
		//System.out.println(r);
		guessnumber(r);
	

	}

	private static void guessnumber(int r) {
		// TODO Auto-generated method stub
		
		//while常用做死循环，循环条件写true,但需要设置出口break
		while(true)
		{
			System.out.println("请输入你猜的整数：");
			int a=new Scanner(System.in).nextInt();
			if (r>a) {
				System.out.println("您猜小了");
			} else if (r<a) {
				System.out.println("您猜大了");
			} else {
				System.out.println("恭喜中奖");
				break;
			}

			
		}
	}

	private static int creatNum() {
		//
		int random=new Random().nextInt(10);
		return random;
	}

}

产生10以内（不包含10）的随机数：

int random=new Random().nextInt(10);

do-while循环

do｛循环体｝while（循环条件）

package cn.tedu.basic;

import java.util.Random;


public class TesatDoWhile {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int n;
		do {
			System.out.println("我是循环体");
			n=new Random().nextInt(300);
			System.out.println(n);
		}while(n>100);

	}

}

循环结构的区别

for：知道循环次数

while/do while：当循环次数不确定时

while：先判断，不符合规则，不执行代码

do while：代码最少被执行一次，再去判断，符合规则，再次执行代码

数组

数组的内存空间是连续的

 动态初始化：知道数组的长度，后续给每个元素赋值

int[] a = new int[5];

静态初始化：创建数组的时候已经确定了每个元素具体的值

int[] b = new int[]{1,2,3,4,5};

int[] c = {1,2,3,4,5};

char类型的数组，在底层代码中做了处理，可以直接查看数组中的元素

其他数组需用Arrays.toString（数组名）

public class TestArray {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		char[] c1= {'h','e','l','l','o'};
		char[] c2= new char[] {'h','e','l','l','o'};
		char[] c3=new char[5];
		c3[0]='h';
		c3[1]='e';
		c3[2]='l';
		c3[3]='l';
		c3[4]='0';
		
		System.out.println(c1);
		System.out.println(c2);
		System.out.println(c3);
		
		String[] s1=new String[]{"a","b","c"};
		String[] s2= {"a","b","c"};
		String[] s3=new String[3];
		s3[0]="a";
		s3[1]="b";
		s3[2]="c";
		//char类型的数组，在底层代码中做了处理，可以直接查看数组中的元素
		//其他数组需用Arrays.toString（数组名）
		System.out.println(Arrays.toString(s1));
		System.out.println(Arrays.toString(s2));
		System.out.println(Arrays.toString(s3));

	}

}

int是整数型，int[]是引用型，所以当他们为成员变量时，返回值不同，int返回0，int[]是null；

数组的复制：

复制整个数组：Arrays.copyof（要复制的那个数组名，新数组的长度）

对指定位置复制：copyOfRange(要截取的数组，开始位置，结束位置)

package cn.tedu.array;

import java.util.Arrays;
//数组的扩容和缩容
public class TestArraysCopyOf {
	public static void main(String[] args) {
		int[] from= {1,2,3,4,5};
		//数组的复制
		int[] to=Arrays.copyOf(from, 5);
		System.out.println(Arrays.toString(to));
		System.out.println(Arrays.toString(from));
		//数组的扩容
		int[] to2=Arrays.copyOf(from, 10);
		System.out.println(Arrays.toString(to2));
		//数组的缩容
		int[] to3=Arrays.copyOf(from, 4);
		System.out.println(Arrays.toString(to3));
		//数组的截取
		int[] to4=Arrays.copyOfRange(from, 2, 4);
		System.out.println(to4);
				
	}

}

冒泡排序

package cn.tedu.basic;

import java.lang.reflect.Method;
import java.util.Arrays;


public class BubbleSort {
	public static void main(String[] args) {
		int[] a= {27,96,73,25,21};
		Method(a);
	}
	private static void Method(int[] a) {
		// TODO Auto-generated method stub
		int b;
		for (int i = 1; i <= a.length-1; i++) {
			for (int j = 0; j <a.length-i; j++) {
				if(a[j]<a[j+1]) {
					b=a[j];
					a[j]=a[j+1];
					a[j+1]=b;
				}
			}
		}
		System.out.println(Arrays.toString(a));
	}
}

对数组快速排序：Arrays.sort(数组名);