关于循环
- 总结：
-
1、for:固定次数循环，应用率比较高
-
2、break：跳出循环
-
continue：跳过循环体中的剩余语句而进入下一次循环
-
3、嵌套循环：
-
（1）嵌套中的循环，一般多行多列的时候，外层控制行，内层控制列；
-
（2）执行规则：外层循环走一次，内层走所有次
-
（3）建议：循环层数越少越好，如果能用一层解决的不要用多层
-
如果说你写的程序使用到了3层以上循环，那么就考虑程序的设计是否有问题；
-
（4）break只能跳出一层循环；
for(int i = 0;i < 10;i++){ if(i % 2 == 0){ continue; } System.out.println(i); }for(int j = 0; j < 5; j++){
if(j == 2){
break;
}
System.out.println(j);
}
-
关于猜数字：
-
1、导包
-
2、创建对象Random r = new Random();
-
3、获取随机数：int num = r.nextInt(100);
-
产生的数据在0-100之间，包括0，不包括100，
-
括号里面的100是可以变化的，如果是1000，就是0-1000里面的数据
import java.util.Random; import java.util.Scanner; public class RandomDemo { public static void main(String[] args) { Random r = new Random(); System.out.println("开始猜吧"); int number = r.nextInt(100); //创建对象 Scanner sc = new Scanner(System.in); //接收数据---guess：猜的数字 int guess = sc.nextInt(); while(guess != number){ if(guess>number){ System.out.println("猜大了"); }else{ System.out.println("猜小了"); } guess = sc.nextInt(); } if(guess==number){ System.out.println("猜对了"); } sc.close(); } }
数组
-
1、数组概念：存储同一种数据类型多个元素的容器；
-
数组既可以存储基本数据类型；也可以存储引用数据类型；
-
2、数组的定义格式：
-
格式1：数组类型[]数组名;
-
格式2：数组类型 数组名[];
-
3、初始化
-
动态初始化：在初始化的时候，只定义了数组的长度，通过系统来决定数组的初始化的值；
-
静态初始化：在初始化的时候，指定了每一个数组元素的初始化的值，由系统决定数组的长度。
public class hhxxxl { public static void main(String[] args) { //声明一个数组；初始化 int[] arr = new int[5];//第一种，比较常用 int arr1[] = new int[5];//第二种，不推荐 //数组的初始化 int[] arr2 = new int[3];//动态初始化 0 int[] arr3 = new int[]{1,3,5,7};//静态初始化 int[] arr4 = {1,3,3,5,6};//简化形式 System.out.println(arr2[2]);//0 System.out.println(arr3[1]);//3 int[] arr5; //arr5 = {1,3,2}; 错误的写法 arr5 = new int[]{1,3,2}; //对的 System.out.println(arr.length); //数组遍历 for( int i = 0; i < arr.length; i++){ System.out.println(arr[i]); } } }
2、数组的存储形式
-
栈：
-
存储的是局部变量；
-
局部变量就是定义在方法体中的变量；
-
使用完毕后，会立即释放。
-
堆：
-
存储的是new出来的对象：
-
每一个对象都是有地址值的；
-
每一个对象都是有默认值的。
-
byte; short; int; long 0;
-
float; double; 0.0
-
char ‘\u0000’
-
boolean false
-
引用数据类型 null
-
使用完毕后空间，由垃圾回收器在空闲时回收
-
NullPointerException空指针异常
public class ArrayDemo {
public static void main(String[] args) {System.out.println("程序开始执行！"); try { int[] arr = {1,2,3}; arr = null;//空指针，变为垃圾 System.out.println(arr[1]); System.out.println(arr[3]); }catch(ArrayIndexOutOfBoundsException e){ System.out.println("发生了数组下标越界"); }catch (NullPointerException e){ System.out.println("空指针异常"); } catch (Exception e) { e.printStackTrace(); } System.out.println("1234"); System.out.println("程序结束执行……"); } }练习
-
身份证的最后一位
import java.util.Scanner;public class idcard { public static void main(String[] args) { //用来存放用户输入的前17位 int[] card = new int[17]; //用来存放前17位对应的系数 int[] data = {7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2}; char[] code = {'1','0','x','9','8','7','6','5','4','3','2'}; int sum = 0; Scanner sc = new Scanner(System.in); for(int i = 0; i < card.length; i++){ System.out.println("请输入身份证的第" + i +"位"); card[i] = sc.nextInt(); } for(int i = 0; i < card.length; i++){ sum += card[i]*data[i]; } System.out.println("最后一位" +code [sum%11]); sc.close(); } }数组复制
-
数组的复制：
-
Array.CopyOf(src, length)
-
jdk1.6版本提供的，使用的时候要注意在1.6版本及以上使用
-
2、System.arraycopy(src, srcPos,dest, destPos,length);
-
src：原数组
-
srcPos:原数组的开始的复制的位置
-
dest: 目标数组
-
destPos:目标数组的开始复制的位置
-
length:复制的长度
-
javaAPI提供的，底层是用c++写的，所以速度非常快，比for（）循环实现数组的拷贝效率要高，推荐使用
import java.util.Arrays;
public class ArrayDemo02 {
public static void main(String[] args) {int[] arr = {5,2,3}; int[] arr2 = Arrays.copyOf(arr, arr.length ); int[] arr3 = new int[3]; //数组的输出，用Arrays.toString，这个输出值 //直接输出arr2,输出的是地址 System.out.println(Arrays.toString(arr)); System.out.println(Arrays.toString(arr2)); System.out.println("------"); //另一个复制的代码 原数组 开始 目标 开始 长度 System.arraycopy(arr,0,arr3,0,arr.length); System.out.println(Arrays.toString(arr3)); System.out.println("-----"); //数组遍历 挨个输出数组内元素 for(int i = 0; i < arr2.length; i++){ System.out.println(arr2[i]); }}
]-
数组的扩展
import java.util.Arrays;
public class ArrayDemo03 {
public static void main(String[] args) {char[] arr = {'北','京'}; //扩大容量，arr2复制arr,并扩大内存空间为4 char[] arr2 = Arrays.copyOf(arr,4); //arr2和arr3共用内存空间 char[] arr3 = arr2; arr3[2] = '达'; arr3[3] = '内'; System.out.println(arr3); System.out.println(arr3 == arr2); System.out.println(arr2[2]); System.out.println(arr2[3]);}
}
-
冒泡排序
-
数组的排序：冒泡排序
public class ArrayDemo04 {
public static void main(String[] args) {//定义一个数组对象 int[] arr = {1,3,23,53,4,23,54}; //冒泡排序算法，n-1轮比较，得到最终的h boolean isSorted;//优化 for(int i = 0; i < arr.length - 1; i++){ isSorted = true; for(int j = 0; j < arr.length - 1; j++){ if(arr[j] > arr[j + 1] ){ int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; //没排好进这个 isSorted = false; } System.out.println("第" +i +"轮：" +",arr[j]" + arr[j] ); } System.out.println("轮"+ i); if(isSorted){ break; } } System.out.println("排序后的数组"); for(int i = 0; i < arr.length; i++){ System.out.println(arr[i]); }}
} -
arr:2，6，1，4
-
第0轮：2.1.4.6
-
第1轮：1.2.4
-
第2轮：1.2
-
求数组中的最大值
public class ArrayDemo01 { public static void main(String[] args) { //1、产生一个数组 int arr[] = {17,5,64,25,45,3,5}; //2、取一个参考值 int max = arr[0]; System.out.println("数组的元素包括："); for( int i = 0; i < arr.length; i++){ if(arr[i] > max){ max = arr[i]; } System.out.println("max:" +max); } }}
方法
- 方法：（函数、过程）
- 1、概念
- 封装了一段特定的业务逻辑的功能
- 尽可能是独立的，让一个方法去干一件事；
- 方法可以重复去调用
- 优点：写方法可以减少代码重复，有利于代码后期维护，同时减少团队开发成本
- 2、语法结构
- 修饰词+返回值类型+方法名（参数列表）{
- 方法体：//具体的业务逻辑功能
- return；//返回值
- }
- 修饰词：public static（目前使用）
- 返回值类型：用于限定返回值的具体的类型
- 方法名：为了调用的时候，方便起的名字
- 参数列表:（数据类型+参数名，数据类型+参数名2……）
- 参数类型：用于限定传入的数据类型
- 参数名：用于接收调用方法时传入的数据的变量
- 3、方法的使用
- 1)明确方法是否有返回值
- 2）方法是否有参数列表
- 4、方法的调用
- 1）单独去调用：不建议
- 2）输出调用：有意义的，不太完善，因为可能需要对得到的数字进行处理
- 3）赋值调用：推荐使用
- @author Administrator
public class BubbleSort {
public static void main(String[] args) {
//求和
int x = 5;
int y = 8;
int num = sum(x,y);
int y1 = num / 10;
System.out.println(num);
double salary = getSalary();
System.out.println(salary);
String name = "pipi";
sayHi(name,"东京");
}
//求和，有返回值有参数
public static int sum(int x, int y){
return x + y;
}
//有返回值，无参数
public static double getSalary(){
return 30000.0;
//return；编译错误
//return “123” ：编译错误，返回值类型必须进行匹配
}
//无返回值，有参数
public static void sayHi(String name,String address){//形参,void是无参
System.out.println("大家好，我叫" +name);
}
//无返回值，无参数
public static void sayHi(){
System.out.println("大家好，我叫佩奇");
}
}
- 总结：
- 1、for:固定次数循环，应用率比较高
- 2、break：跳出循环
- continue：跳过循环体中的剩余语句而进入下一次循环
- 3、嵌套循环：
- （1）嵌套中的循环，一般多行多列的时候，外层控制行，内层控制列；
- （2）执行规则：外层循环走一次，内层走所有次
- （3）建议：循环层数越少越好，如果能用一层解决的不要用多层
- 如果说你写的程序使用到了3层以上循环，那么就考虑程序的设计是否有问题；
- （4）break只能跳出一层循环；
public class Test {
public static void main(String[] args) {
for(int j = 0; j < 5; j++){
if(j == 2){
break;
}
System.out.println(j);
}
for(int i = 0;i < 10;i++){
if(i % 2 == 0){
continue;
}
System.out.println(i);
}
}
}
练习：用方法从键盘录入学生姓名和成绩，进行排序
class StudentInfo{
private String name;
private int score;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public void sort(StudentInfo[] stu,int count)
{
StudentInfo temp;
for(int i=0;i<count;i++)
{
for(int j=0;j<count-i-1;j++)
{
if (stu[j].getScore()<stu[j+1].getScore())
{
temp=stu[j];
stu[j]=stu[j+1];
stu[j+1]=temp;
}
}
}
}
public void print(StudentInfo[] stu,int count){
for (int i=0; i<count;i++) {
System.out.println(stu[i].getName()+" "+stu[i].getScore());
}
}
}
另一个类;ScoreSort.java
package cn.tedu.day04;
import java.util.Scanner;
public class ScoreSort {
public static void main(String[] args){
StudentInfo s=new StudentInfo();
StudentInfo[] stu= new StudentInfo[20];
Scanner sc= new Scanner(System.in);
System.out.println("请输入学生个数：");
int count=sc.nextInt();
int num=0;
while(num<count) {
System.out.println("请输入第"+(num+1)+"个学生的姓名和分数：");
Scanner scan=new Scanner(System.in);
String strLine=scan.nextLine();
String[] strLineArr = strLine.split(" ");
StudentInfo st = new StudentInfo();
st.setName(strLineArr[0]);
st.setScore(Integer.parseInt(strLineArr[1]));
stu[num]=st;
num++;
}
s.sort(stu,count);
System.out.println("排序后的学生信息为:");
s.print(stu,count);
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
