特殊流程控制
Braek:
public class Text1{
public static void main(String[]args){
for(int i=0 ;i<10 ;i++ ){
if(i==3){
break;
}
System.out.println("i="+i);
}
System.out.println("Game Over!");
}
}
Continue:
public class Text1{
public static void main(String[]args){
for(int i=0 ;i<100 ;i++ ){
if(i%10==0){
continue;
}
System.out.println("i="+i);
}
}
}
/*
break使用在 switch-case 循环结构中，作用是跳出当前循环
continue使用在循环结构中，跳出当次循环
*/
class code2{
public static void main(String[] args)
{
System.out.println("Hello World!");
for(int i=1 ;i<=10 ;i++ ){
if(i%4==0){
//break;
continue;
}
System.out.println(i);
}
level:for(int i=1 ;i<=5 ;i++ ){
for(int j=1 ;j<=10 ;j++ ){
if(j%4==0){
//break;123
//continue;1235678910
//break level;123132123123123
continue level;
}
System.out.print(j);
}
System.out.println();
}
}
}
//输出100以内的素数
public class code1{
public static void main(String[]args){
boolean b=false;
Lable:for(int i=2 ; i<=100;i++){
for(int j=2 ; j<Math.sqrt(i) ;j++ ){
if(i%j==0){
//b=true;
break Lable;
}
}
// if(!b){
System.out.println(i);
// }
// b=false;
}
}
}
Return:
return：并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。
与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内
注意：
break只能用于switch语句和循环语句中。
continue 只能用于循环语句中。 If ?\While +switch while +continue
二者功能类似，但continue是终止本次循环，break是终止本层循环。
break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。
/*
编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，
对它们进行排序(使用 if-else if-else),并且从小到大输出。
*/
import java.util.*;
public class code3{
public static void main(String[]args){
Scanner scanner =new Scanner (System.in);
System.out.println("由键盘输入三个整数分别存入变量num1、num2、num3");
int a=0,b=0,c=0;
boolean tt=true;
L:while(tt){
try{
tt=false;
a=scanner.nextInt();
switch (a)
{
case 1:
continue L;
}
b=scanner.nextInt();
c=scanner.nextInt();
break;
}catch(Exception e){
System.out.println("输入错误!\n由键盘输入三个整数分别存入变量num1、num2、num3");
//scanner.close();
scanner =new Scanner (System.in);
tt=true;
continue;
}
}
if(a>b){
if(c>a){
System.out.println(c+">"+a+">"+b);
}else if(c<b){
System.out.println(a+">"+b+">"+c);
}else{
System.out.println(a+">"+c+">"+b);
}
}else{//b>a
if(c>b){
System.out.println(c+">"+b+">"+a);
}else if(c<a){
System.out.println(b+">"+a+">"+c);
}else{
System.out.println(b+">"+c+">"+a);
}
}
}
}
/*
一个数如果恰好等于它的因子之和，这个数就称为"完数"。（因子：除去这个数本身正的约数）
例如6=1＋2＋3.编程 找出1000以内的所有完数
*/
class code4
{
public static void main(String[] args)
{
int factor=0;
int count=0;
for(int i=0;i<100;i++){
for(int j=1;j<i;j++){
if(i%j==0){
factor+=j;
}
}
if(factor==i){
System.out.println(i);
count++;
}
factor=0;
}
System.out.println("最后的数量为"+count);
}
}
数组
数组是多个相同类型数据的组合，实现对这些数据的统一管理
数组中的元素可以是任何数据类型，包括基本类型和引用类型
数组属引用类型，数组型数据是对象(object)，数组中的每个元素相当于该对象的成员变量
一维数组声明
一维数组的声明方式：
type var[] 或 type[] var；
例如：
int a[];
int[] a1;
double b[];
Mydate[] c; //对象数组
Java语言中声明数组时不能指定其长度(数组中元素的数)， 例如： int a[5]; //非法
一维数组初始化
动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行
int[] arr = new int[3];
arr[0] = 3;
arr[1] = 9;
arr[2] = 8;
MyDate dates[];
dates = new MyDate[3];
dates[0] = new MyDate(22, 7, 1964);
dates[1] = new MyDate(1, 1, 2000);
dates[2] = new MyDate(22, 12, 1964);
静态初始化：在定义数组的同时就为数组元素分配空间并赋值。
int a[] = new int[]{ 3, 9, 8};
int[] a = {3,9,8};
MyDate dates[] = {
new MyDate(22, 7, 1964),
new MyDate(1, 1, 2000),
new MyDate(22, 12, 1964)
}
public class Text2{
public static void main(String[]args){
//int [] arr =new int [3];
int arr [] =new int [3];
arr[0]=3;
arr[1]=9;
arr[2]=8;
for(int a:arr)
System.out.println(a);
person p[]={new person( "王琪" , 87 ),new person( "方法" , 87),new person( "好好",89 )};
for( person a :p ){
System.out.println(a.toString());
}
}
static class person{
String name;
int age;
public person(String name,int age){
this.name=name;
this.age=age;
}
public String toString(){
return "name+"+name+"age"+age;
}
}
}
Java内存的结构
栈(stack) 堆 (heap) 方法区 字符串常量池 静态域
int[] scores = new int[3];
scores[0] = 78;
scores[1] = 88;
scores[2] = 98;
String[] names= new String[3];
names[0] = “商文通”;
names[1] =“汤化峰”;
int[] myInt = new int[5];
for(int i = 0;i < myInt.length;i++){
sysout(myInt[i]);
myInt[i] = 2*i+1;
sysout(myInt[i]);
class Text3{
public static void main(String[] args){
System.out.println("Text3");
int [] score = new int [3];
score [0] = 78;
score [1] = 88;
score [2] = 98;
String[] name= new String [3];
name[0] = "王琪";
name[1] = "你好";
int [] myInt=new int [5];
for(int i=0 ;i<myInt.length ; i++){
System.out.print(myInt[i]+" ");
myInt[i] = 2*i+1;
System.out.println(myInt[i]);
}
}
}
创建基本数据类型数组
Java中使用关键字new创建数组对象
创建基本数据类型一维数组对象
class Text4{
public static void main(String[] args)
{
System.out.println("Hello World!");
int [] s;
s = new int [10];
for( int i=0 ;i<10 ;i++ ){
s[i]=2*i+1;
System.out.println(s[i]);
}
}
}
public class Test{
public static void main(String args[]){
int[] s;
s = new int[10];
//int[] s=new int[10];
//基本数据类型数组如果没有赋初值，
//Java自动给他们赋默认值。
for ( int i=0; i<10; i++ ) {
s[i] =2*i+1;
System.out.println(s[i]);
}
}
}
创建对象数组
创建元素为引用类型(对象)的数组
class MyDate{
private int day;
private int month;
private int year;
public MyDate(int d, int m, int y){
day = d; month = m; year = y;
}
public void display(){
System.out.println(year + "-" + month + "-" + day);
}
}
class Text5{
public static void main(String[] args)
{
MyDate [] date1;
date1 = new MyDate [4];
MyDate [] date2;
date2 =new MyDate[4];// {new MyDate(1,2,3),new MyDate(1,2,3),new MyDate(1,2,3)};
//MyDate [] date3;
///date3 = {new MyDate(1,2,3),new MyDate(1,2,3),new MyDate(1,2,3)};
MyDate [] date4={new MyDate(1,2,3),new MyDate(1,2,3),new MyDate(1,2,3)};
}
static class MyDate{
int day;
int month;
int year;
public MyDate(int d,int m,int y){
this.day=d;
this.month=m;
this.year=y;
}
public void display(){
System.out.println(year+"-"+month+"-"+day);
}
}
}
package com.atguigu.java;
/*
* 数组 ： 数（即变量）的组合 ，这些变量一定是享有同数据类型的
*/
public class code1 {
public static void main(String[] args) {
int q=12;
boolean b=false;
String str ="MM";
//数据的声明与初始化
//1.1声明
int [] scores;//int 型数组的声明
String [] names;
//1.2初始化
//静态初始化
names = new String []{"1", "2", "3" ,"4" ,"5"};
double [] hight = new double []{1.223,13.213213,13.123123,1322.132123,131.1331};
//动态初始化
scores=new int [5];
//2如何调用数组中的元素，使用下标
//数组的元素下标从0开始，到n-1节结束
scores[0]=90;
scores[1]=80;
//数组的长度还会在建立时就决定(.length属性调用)
System.out.println(names.length);
System.out.println(scores.length);
//如何遍历一个数组
for(int a=0 ;a<names.length ;a++ ){
System.out.println(names[a]);
}
for(int c=0 ;c<scores.length ;c++ ){
System.out.println(scores[c]);
}
//创建不同类型的数组的元素的默认初始化问题；
//创建 byte/short/int/long默认的初始化值为0
short [] sh1=new short[3];
for(short sh:sh1){
System.out.println(sh);
}
char [] ch1 =new char [3];
for(char c:ch1){
System.out.println( c==' ');
}
//float/double 数组默认的类型为0.0
float [] f1 =new float[3];
for(int i=0 ;i<f1.length ;i++ ){
System.out.println(f1[i]);
}
//boolean的默认人初始化为false
boolean [] b1=new boolean[3];
for(boolean bb:b1){
System.out.println(bb);
}
// 创建的是引用数据类型数组；默认的初始化值为null
String [] strs=new String [4];
for(String s:strs){
System.out.println(s);
}
person1 []p1=new person1[]{};
}
}
class person1{
}
数组元素的默认初始化
数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。例如：
public class Test {
public static void main(String argv[]){
int a[]= new int[5];
System.out.println(a[3]); //a[3]的默认值为0
}
}
对于基本数据类型而言，默认初始化值各有不同
对于引用数据类型而言，默认初始化值为null(注意与0不同！)
package com.atguigu.java;
public class code2 {
public static void main(String[] args) {
//数组的引用
String[] s = new String[] {"haha" ,"hehe" , "hihi",};
String [] ss=s;
ss[0]="gg";
System.out.println(ss[0]+" "+s[0]);
//数组一旦初始化，其长度不可以改变
int score1[]=new int []{11,22,33,44};
int score2[]=new int[6];
for(int i=0;i<score1.length;i++){
score2[i]=score1[i];
}score2[4]=12;score2[3]=31;
for(int a :score1)
System.out.println(a);
for(int a :score2)
System.out.println(a);
}
}
数组元素的引用
定义并用运算符new为之分配空间后，才可以引用数组中的每个元素；
数组元素的引用方式：数组名[数组元素下标]
数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];
数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 —>n-1；如int a[]=new int[3]; 可引用的数组元素为a[0]、a[1]、a[2]
每个数组都有一个属性length指明它的长度，例如：a.length 指明数组a的长度(元素个数)
数组一旦初始化，其长度是不可变的
练习1
1.(1)定义类Pritimive，在类中定义一个有3个元素的boolean类型的数组t作为其成员变量。数组元素未赋值。
定义类Array1，在Array1的main()方法中创建Pritimive对象d，输出其成员变量t的三个元素值。
练习目的：检验基本数据类型数组创建时的自动赋值。
(2)给对象d的成员变量t赋值为{true,true,true}，并输出t的三个元素值。
/*
*定义类Pritimive，在类中定义一个有3个元素的boolean类型的数组t作为其成员变量。数组元素未赋值。
定义类Array1，在Array1的main()方法中创建Pritimive对象d，输出其成员变量t的三个元素值。
练习目的：检验基本数据类型数组创建时的自动赋值。
*/
package com.atguigu.java;
public class code3 {
public static void main(String[] args) {
Primitive p=new Primitive();
for(int i=0 ;i<p.t.length;i++){
System.out.println(p.t[i]);
}
p.t[0]=true;
p.t[1]=true;
p.t[2]=true;
for(int i=0 ;i<p.t.length;i++){
System.out.println(p.t[i]);
}
}
}
class Primitive{
boolean [] t =new boolean[3];
}
2. 定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定，打印出3年级(state值为3）的学生信息。
提示：生成随机数：Math.random()，返回值类型double;
四舍五入取整：Math.round(double d)，返回值类型long。
/*
* 定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。
* 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定，打印出3年级(state值为3）的学生信息。
提示：生成随机数：Math.random()，返回值类型double;
四舍五入取整：Math.round(double d)，返回值类型long。
*/
package com.atguigu.java;
//1定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)
class student1{
int numbe;
int state;
int score;
public String toString(){
return ("学号:"+numbe+"年级:"+state+"成绩:"+score);
}
}
public class code7 {
public static void main(String[] args) {
//2.创建20个学生对象，学号为1到20，年级和成绩都由随机数确定
student1 [] st = new student1[20];
for(int i=0;i<st.length;i++){
st[i]=new student1();
st[i].numbe=i+1;
st[i].state=nianji();
st[i].score=chengji();
System.out.println(st[i]);
}
//3.打印出3年级(state值为3）的学生信息
}
public static int nianji(){
return (int)(Math.random()*10)%3;
}
public static int chengji(){
return (int)(Math.random()*100)%100;
}
}
/*
* 学号:1年级:2成绩:59
学号:2年级:0成绩:50
学号:3年级:0成绩:59
学号:4年级:2成绩:89
学号:5年级:1成绩:11
学号:6年级:0成绩:90
学号:7年级:2成绩:20
学号:8年级:1成绩:55
学号:9年级:0成绩:64
学号:10年级:1成绩:76
学号:11年级:0成绩:82
学号:12年级:1成绩:62
学号:13年级:0成绩:13
学号:14年级:0成绩:57
学号:15年级:0成绩:10
学号:16年级:2成绩:45
学号:17年级:1成绩:50
学号:18年级:2成绩:99
学号:19年级:2成绩:16
学号:20年级:0成绩:49
*/
3. 从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
成绩>=最高分-10 等级为’A’
成绩>=最高分-20 等级为’B’
成绩>=最高分-30 等级为’C’
其余 等级为’D’
提示：先读入学生人数，根据人数创建int数组，存放学生成绩。
/*
*
*3. 从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
成绩>=最高分-10 等级为’A’
成绩>=最高分-20 等级为’B’
成绩>=最高分-30 等级为’C’
其余 等级为’D’
提示：先读入学生人数，根据人数创建int数组，存放学生成绩。
*/
package com.atguigu.java;
import java.util.Scanner;
public class code5 {
static int max;
public static void main(String[] args) {
Scanner s= new Scanner(System.in);
//1根据提示创建一个Scanner类对象，输入学生个数
System.out.println("please input the number of students:");
int num=s.nextInt();
//2根据写入的学生信息，建立相当长度的int数据
int student[]=new int [num];
//3通过循环从键盘输入学生成绩
System.out.println("input the "+num+" goards");
for(int i=0;i<num;i++){
student[i]=s.nextInt();
}
//4遍历数组元素 同事获得最大值
max=student[0];
for(int a:student){
if(a>max){
max=a;
}
}
//获得学生等级
System.out.println("最高分:"+max+" ");
System.out.println("A:>="+(max-10)+"B:>="+(max-20)+"C:>="+(max-30)+"D:");
for(int i=0;i<num;i++){
System.out.println("student"+"["+i+"]="+fun(student[i]));
}
}
public static char fun(int a){
if(a>=max-10){
return 'A';
}else if(a>=max-20){
return 'B';
}else if(a>=max-30){
return 'C';
}else{
return 'D';
}
}
}
多维数组
二维数组[][]：数组中的数组
格式1（动态初始化）：int[][] arr = new int[3][2];
定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称分别为arr[0], arr[1], arr[2]
给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;
格式2（动态初始化）：int[][] arr = new int[3][];
二维数组中有3个一维数组。
每个一维数组都是默认初始化值null (注意：区别于格式1）
可以对这个三个一维数组分别进行初始化
arr[0] = new int[3]; arr[1] = new int[1]; arr[2] = new int[2];
注：
int[][]arr = new int[][3]; //非法
格式3（静态初始化）：int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
定义一个名称为arr的二维数组，二维数组中有三个一维数组
每一个一维数组中具体元素也都已初始化
第一个一维数组 arr[0] = {3,8,2};
第二个一维数组 arr[1] = {2,7};
第三个一维数组 arr[2] = {9,0,1,6};
第三个一维数组的长度表示方式：arr[2].length;
注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。
Java中多维数组不必都是规则矩阵形式
package com.atguigu.java;
public class code6 {
public static void main(String[] args) {
//\/int [] arr =new int[];
//1.二维数组的声明与初始化
//1.1动态初始化
int [][] arr1 = new int [4][3];
int [][] arr2 = new int [4][];
//2如何引用二维数组中的元素
arr1 [0][0] = 10;
arr2 [3][2] = 20;
arr2 [0] = new int [3];
//arr2 [1][17]=10; //??????
arr2 [1] = new int [4];
arr2 [1] = new int [5];
arr2 [2] = new int [7];
//1.1静态初始化
int [][] arr3 = new int [][]{{1,2,3,4,5},{3,4,5,6},{4,5,6}};
}
}
练习2：获取arr数组中所有元素的和。使用for的嵌套循环即可。
声明：int[] x,y[]; 以下选项允许通过编译的是：
a ) x[0] = y; no
b) y[0] = x; yes
c) y[0][0] = x;no
d) x[0][0] = y;no
e) y[0][0] = x[0];yes
f) x = y; no
public class code9 {
//二维数组的定义和初始化
//二维数组的动态定义
public static void main(String[] args) {
int [] x = null,y[]=null;
//x[0]=y;
y[0]=x;
//y[0][0]x;
//x[0][0]=y;
y[0][0]=x[0];
}
}
一维数组：int[] x 或者int x[]
二维数组：int[][] y 或者 int[] y[] 或者 int y[][]
使用二维数组打印一个 10 行杨辉三角.
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
....
package com.atguigu.java;
public class code8 {
public static void main(String[] args) {
new YangHui().fun();
}
}
class YangHui{
public void fun(){
int [][] yanghui = new int [10][];
for(int i=0 ;i<yanghui.length ;i++ ){
yanghui[i]=new int [i+1];
yanghui[i][0]=yanghui[i][i]=1;
for(int j=1 ;j<i ;j++){
yanghui[i][j]=yanghui[i-1][j-1]+yanghui[i-1][j];
}
}
//遍历
for( int i=0;i<yanghui.length ;i++ ){
for(int j=0 ;j<yanghui[i].length ;j++ ){
System.out.print(yanghui[i][j]+" ");
}
System.out.println();
}
}
}
/*
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
*/
【提示】
1. 第一行有 1 个元素, 第 n 行有 n 个元素
2. 每一行的第一个元素和最后一个元素都是 1
3. 从第三行开始, 对于非第一个元素和最后一个元素的元素.
yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
1.求数组元素的最大值、最小值、平均数、总和等
2.数组的复制、反转
3.数组元素的排序
定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，最小值，平均值，和值，并输出出来。
使用简单数组
(1)创建一个名为TestArray的类，在main()方法中声明array1和array2两个变量，他们是int[]类型的数组。
(2)使用大括号{}，把array1初始化为8个素数：2,3,5,7,11,13,17,19。
(3)显示array1的内容。
(4)赋值array2变量等于array1，修改array2中的偶索引元素，使其等于索引值(如array[0]=0,array[2]=2)。打印出array1。
思考：array1和array2是什么关系？
拓展：修改题目，实现array2对array1数组的复制
数组排序
插入排序
直接插入排序、折半插入排序、Shell排序
交换排序
冒泡排序、快速排序（或分区交换排序）
选择排序
简单选择排序、堆排序
归并排序
基数排序
排序方法的选择
(1)若n较小(如n≤50)，可采用直接插入或直接选择排序。
当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插入，应选直接选择排序为宜。
(2)若文件初始状态基本有序(指正序)，则应选用直接插入、冒泡或随机的快速排序为宜；
(3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。
冒泡排序
排序思想：
相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其它的数进行类似操作
数组排序
java.util.Arrays类的sort()方法提供了数组元素排序功能：
import java.util.*;
public class Sort {
public static void main(String[] args) {
int [] number = {5,900,1,5,77,30,64,700};
Arrays.sort(number);
for(int i = 0; i < number.length; i++)
System.out.println(number[i]);
}
}
操作数组的工具类：Arrays
java.util.Arrays类包含了用来操作数组（比如排序和搜索）的各种方法。Arrays拥有一组static方法。
equals()：比较两个array是否相等。array拥有相同元素个数，且所有对应元素两两相等。
fill()：将值填入array中。
sort()：用来对array进行排序。
binarySearch()：在排好序的array中寻找元素。
另：System.arraycopy()：array的复制。
数组操作常见问题
数组脚标越界异常(ArrayIndexOutOfBoundsException)
int[] arr = new int[2];
System.out.println(arr[2]);
访问到了数组中的不存在的脚标时发生。
空指针异常(NullPointerException)
int[] arr = null;
System.out.println(arr[0]);
arr引用没有指向实体，却在操作实体中的元素时。