java方法，冒泡排序，选择排序，插入排序，二分查找，打印正三角形及买彩票案例练习
作者：互联网
方法：
方法（函数），复用性，可读性
方法格式：
访问权限修饰符[其他的修饰符 如static]返回值类型 方法名
public static void getmenu（）{content；}
参数：
实际参数：实际参与运算的
形式参数：接受实际参数的
方法返回值和重载：
return：结束方法
返回值：由return带给调用者
注意：
1.若当前没有返回值类型，即返回值类型为void，方法中不写return
2.return表示结束一个方法，也可以将返回值返回给调用者
3.return返回值一次只能返回一个值，不可以返回多个值
4.一个方法中可以有多个return，但只能被执行一次。
练习：
1.判断任意给定年份是否是闰年？
import java.util,Scanner;
public class Test{
public static void main(String[] args){
boolean bool = isleapyear(n); //调用方法
if(bool){
System.out.println("闰年");
}else{
System.out.println("平年")
}
}
public static boolean isleapyear(int year){
if((year%4==0 && year%100!=0)||year%400==0){
return ture;
}else{
return false;
}
}
}
2.根据传入的参数打印直角三角形
/*
import java.util.Scanner;
public calss Test{
public static void main(String[] args){
for(int i=1;i<=5;i++){
for(int j=i;j<5;j++){
System.out.print(" ");
}
for(int j=1;j<=i*2-1;j++){
System.out.print("*");
}
system.out.println();
}
}
}
*/
import java.until.Scanner;
public class Test{
public static void main(String[] args){
Scanner input=new Scanner(System.in);
int num = input.nextInt();
pritnTriangle(num);
}
public static void printTriangle(int line){
for(int i=1;i<=line;i++){
for(int j=i;j<line;j++){
System.out.print(" ");
}
for(int j=1;j<=i*2-1;j++){
System.out.print("*");
}
Syetem.out.println();
}
}
}
方法的重载：overloading method
在同一个类中，方法名相同，参数列表不同，返回值不能作为重载的条件。
如：public void method(int a){...}
public void method(char c){...}
JAVA数组的定义：
数组：一组能够存储相同数据类型值得变量的集合
创建数组：int[] nums = new int[50];
数组的赋值方式：
1.使用默认的初始值来初始化数组中的每一个元素。eg：int[] scores = new int[3]
2.先声明，然后再赋予默认的初始值。eg：int[] scores;scores = new int[3]
3.先声明，然后再使用指定的值进行初始化。eg：int[]scores = new int[]{**.**.**};
4.简化3.eg：int[]scores = [**.**.**]
数组的遍历：
1.普通for循环
for(int i=0;i<scores.length；i++){
int score = scores[i];
System.out.println(score); //不能直接打印数组名
}
1+.使用增强for循环[foreach循环]
for（数组中元素类型 变量：数组名）{数组中元素类型 临时变量 = 变量}
for(int x:scores){
Syetem.out.println(x);
}
2.可变参数 /*重要，多注意*/
可变参数只能是参数列表中的最后一个
可变参数作为数组使用
public static void print(int...x){
int len = x.length;
for(int i=0;i<len;i++){
System.out.peintln(x[i]);
}
}
print();
数组练习：
1.猜数字游戏demo：
import java.util.Scanner;
import java.util.Random; //生成伪随机数
public class test{
int[] nums = new int[5];
int len = nums.length;
Randon r = new Random(); //创建一个可以生成随机数的工具
for(int i=0;i<len;i++){
r.nextint(50); //随机生成50以内的数
}
//int[] nums = {30,20,10,12}; 固定值
Scanner input = new Scanner(System.in);
System.out.println("please enter you guess num:");
int userNum = input.nextInt();
boolean flag = false;
for(int x:nums){
if(userNum == x){
flag = true;
break;
}
}
if(flag){
System.out.println("congratulation,yes");
}else{
System.out.println("error!,keep going on!");
}
}
2.打印正三角形
eg：
A
B B B
C C C C C
D D D D D D D
E E E E E E E E E
F F F F F F F F F F F
G G G G G G G G G G G G G
import java.util.Scanner;
public class test{
public static void main(String[] args){
char[] cs = {'A','B','C','D','E','F','G'};
//先输入空格，外循环控制行数，
int len = cs.length;
for(int i = 1;i <= len;i++){
for(int j = i;j < len;j++){
System.out.print(" ");
}
for(int j = 1;j <= i*2-1;j++){
System.out.print(cs[i-1]);
}
System.out.println();
}
}
}
3.有3个班级，每个班有3个同学，记录每个同学的成绩，并计算每个班的平均分。
import java.util.Scanner;
public class Test{
public static void main(String[] args){
int[][] scores= {{78,98,88},{87,96,85},{67,78,89}};
//外循环控制行,内循环控制列
int classLen = scores.length;
for(int i = 0;i < classLen;i++){
int sum = 0;
int count = scores[i].length;
for(int j = 0;j < count;j++){
sum+=scores[i][j];
}
int avg = sum/count;
System.out.println("no."+(i+1)+"class avg score"+avg);
}
}
}
4.最大值和最小值
public class test{
public static void main(String[] args){
int[] num = {12,13,45,56,87,55,156};
int max = max(num);
System.out.println("the max num in array:"+max);
int min = min(num);
System.out.println("the max num in array:"+min);
}
public static int max(int[] num){
int max = num[0];
int len = num.length;
for(int i = 0;i < len,i++){
if(num[i] > max){
/*两个数交换位置方法*/
num[i] = num[i]+max;
max = num[i]-max;
num[i] = num[i]-max;
}
}
return max;
}
public static int min(int[] num){
int min = num[0];
int len = num.length;
for(int i = 0;i < len,i++){
if(num[i] < min){
/*两个数交换位置方法*/
num[i] = num[i]+min;
min = num[i]-min;
num[i] = num[i]-min;
}
}
return min;
}
}
冒泡排序：
/*稳定的排序算法*/
import java.util.Scanner;
public class Test{
public static void main(String[] args){
int[] nums = {12,13,45,75,93};
int len = nums.length;
//外循环控制轮数
for(int i = 0;i < len-1;i++){
for(int j = 0;j<len-1-i;j++){
if(nums[j] > nums[j+1]){
nums[j] = nums[j]+nums[j+1];
nums[j+1] = nums[j]-nums[j+1];
nums[j] = nums[j]-nums[j+1];
}
}
}
for(int n : nums){
System.out.println(n);
}
}
}
选择排序算法：
/*每一趟从待排序的数据元素中选出最大或最小的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完，是一种不稳定的排序算法。*/
/*
1.先确定一个最小值（一般选择第一个数），在逐个比较确定最大或最小值，但是最后才交换
2.不稳定eg：5，4，5，2，6；会调换第一个5的位置
*/
import java.util.Scanner;
public class Test{
public static void main(String[] args){
int[] nums = {13,15,68,45,87,45};
int minindex = 0; //记录每次比较最小值的下标
for(int i = 0;i < nums.length-1;i++){
minindex = i; //每轮先确定一个最小值下标
for(int j = i+1;j < nums.length;j++){
if(nums[minindex] > nums[j]){
minindex = j;
}
}
if(minindex != i){ //判断需要交换的数下标是否是自己
nums[minindex] = nums[minindex+i];
nums[i] = nums[minindex]-nums[i];
nums[minindex] = nums[minindex]-nums[i]
}
}
for(int n : nums){
System.out.println(n);
}
}
}
插入排序算法：
/*
从后向前找合适位置后插入：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的子序列的合适位置，直到全部插入排序完为止。
eg:插入扑克牌的方式，每拿一个数和前一个数比较，但是不是交换（记录小标），是设定一个临时变量，最后才交换
*/
import java.util.Scanner;
public class Test{
public static void main(String[] args){
int nums[] = [13,48,68,54,21,45];
for(int i = 1;;i < nums.length;i++){
int temp = nums[i]; //记录操作数
int j = 0;
for(j = i-1;j >= 0;j--){
if(nums[j] > temp){
nums[j+1] = nums[j];
}else{
break;
}
}
if(nums[j+1] != temp){
num[j+1] = temp;
}
}
for(int n : nums){
System.out.println(n);
}
}
}
二分查找算法：
/*必须保证数列有序*/
import java.util.Scanner;
public class Test{
public static void main(String[] args){
int nums[] = [13,48,68,75,85,98];
int _pos = binayrSearch(nums,55);
System.out.println(_pos);
}
public static int binarySearch(int[] num,int key){
int left = 0;
int right = nems.length-1;
while(left <= right){
int mid = (left + right)/2;
if(nums[mid] > key){
right = mid-1;
}else if(nums[mid] < key){
left = mid+1;
}else{
return mid;
}
}
return /*没找到*/ -1;
}
}
Arrays工具类：
用来操作数组的方法，常用方法：
import java.util.Arrays;
1.使用二分查找：
// Arrays.binarySearch(int[] array,int value);
import java.util.Scanner;
import java.util.Arrays;
public class Test{
public static void main(String[] args){
int nums[13,48,68,54,21,45];
int _pos = Arrays.binarySearch(nums,88);
System.out.println(_pos);
}
}
2.数组内容转成字符串的形式输出
// Arrays.toString(intp[] array);
for(int n : nums){
System.out.println(n);
// ==System.out.println(Arrays.toString(nums));
/*
public static String toString(long[] a){
if(a == null)
return "null";
int iMax = a.length - 1;
if(iMax == -1)
return ="[]";
StringBuilder b = new StirngBuilder();
b.append(a[i]);
for(int i = 0; ; i++){
b.append(a[i]);
if(i == iMax)
return b.append(']').toString();
b.append(", ");
}
}
*/
}
3.数组排序
Arrays.sort(int[] array);
//快速排序：
Array.sort(nums);
System.out.println(Arrays.toString(nums));
4.复制指定的数组
// Arrays.copyOf(int[] array,int length/*新数组长度*/);
// Arrays.copyOf(int[] array,int from,int to);
// System.arraycopy(Object src,int srcPos,Object dest,int destPos,int length);
int[] num = Array.copOf(num,10);
System.out.println(Arrays.toString(num));
5.判断两个数组的值是否相等
// Arrays.equals(num，newNum);
6.使用指定元素填充数组
// Arrays.fill(num,value);
练习：双色球模拟综合案例：
/*
说明：投注区分为红球和蓝球区，红球01~33，蓝球01~16，双色球从33个红色球开出6个，从16个蓝球开出1个。
分析：
1.如何产生蓝球和红球？
用户选择是机选还是手选
2.如何接收用户选号？
接收用户号码
生成系统号码
3.如何验证是否中奖？
比较系统号码和用户号码，记录个数
验证是否中奖
系统号码排序
4.公布本期中奖号码？
公布结果
实现步奏：
1.整体实现思路
2.随机取值不重复算法
3.判断是否中奖的逻辑
4.输出结果
*/
import java.util.Scanner;
import java.util.Arrays;
import java.util.Random;
public class Test{
public static void main(String[] args){
//定义相关的变量
int[] userRedBall = new int[6]; //用户选择号码
int[] sysRedBall = new int[6]; //系统生成号码
int userBlueBall = 0; //用户选择的蓝球
int sysBlueBall = 0; //系统生成蓝球
int redCount = 0; //记录用户选择正确的红球
int blueCount = 0; //记录用户选择正确的蓝球
int[] redBall = new int[33]; //用于存储1~33的红球号码
//需要随机生成6个在1~33之间不重复的数算法
for(int i=0;i<redBall.length;i++){
redBall[i] = i+1;
}
//游戏开始
System.out.println("let's start!");
System.out.ptintln("by computer 1 or by self 2??");
Scanner input = new Scanner(System.in);
Random r = new Random();
boolean flag = true; //判断输入是否正确
while(flag){
int isAuto = input.nextInt();
switch(isAuto){
case 1:
computerSelect(redBall,userRedBall); //机选红球
userBlueBall = r.nextInt(16)+1; //机选蓝球
flag = false;
break;
case 2:
System.out.printIn("please enter 6 redball no in 1~33:");
for(int i=0;i<userRedBall.length;i++){
userRedBall[i] = input.nextInt();
}
System.out.println("please select a blue no in 1~16:");
userBlueBall = input.nextInt();
flag = false;
break;
default:
System.out.ptintln("by computer 1 or by self 2??");
break;
}
}
//系统随机生成号码
//红球
computerSelect(redBall,sysRedBall);
//蓝球
systemBlueBall = r.nextInt(16)+1;
//统计结果：
//统计红球
for(int i=0;i<userRedBall.length;i++){
for(int j=0;j<sysRedBall.length-redCount;j++){
if(userRedBall[i]==sysRedBall[j]){
int temp = sysRedBall[j];
sysRedBall[j] = systemRedBall[sysRedBall.length-1-redCount];
systemRedBall[sysRedBall.length-1-redCount] = temp;
redCount++;
break;
}
}
}
//统计蓝球
if(userBlueBall==sysBlueBall){
blueCount = 1;
}
//验证是否中奖
if(blueCount==0 && redCount<=3){
System.out.println("miss award.");
}else if(blueCount==1 && redCount<3){
System.out.println("yes,you win $5!");
}else if((blueCount==1 && redCount==3) || (blueCount==0 && redCount==4)){
System.out.peintln("yes,you win $10!");
}else if((blueCount==1 && redCount==4) || (blueCount==0 && redCount==5)){
System.out.println("yes,you win $200!");
}else if(blueCount==1 && redCount==5){
System.out.println("yes,you win $3000!");
}else if(blueCount==0 && redCount==6){
System.out.println("yes,you win $1500000!");
}else if(blueCount==1 && redCount==6){
System.out.println("yes,you win $5000000!");
}else{
System.out.println("System Error!")
}
//公布系统号码
System.out.println("the redBall no in range:");
sort(sysRedBall);
System.out.println(Array.toString(sysRedBall));
System.out.println("the blueBall no in range:"+sysBlueBall);
//公布用户号码
System.out.println("the redBall selected by you:");
sort(userRedBall);
System.out.println(Array.toString(userBlueBall));
System.out.println("the blueBall selected by tou:"+userBlueBall);
//end
System.out.println("thanks for you buying the event!")
}
//冒泡排序
public static void sort(int[] ball){
for(int i=0;i<ball.length-1;i++){
for(int j=0;j<ball.length-1-i;j++){
if(ball[j]>ball[j+1]){
ball[j] = ball[j]+ball[j+1];
ball[j+1] = ball[j]-ball[j+1];
ball[j] = ball[j]-ball[j+1];
}
}
}
}
//在指定数列中，随机生成多个不重复的数算法
public static void computerSelect(int[] redBall,int[] userredBall){
Random r = new Random();
int index = -1;
for(int i=0;i<userRedBall.length;i++){
index = r.nextInt(redBall.length-i);
userRedBall[i] = redBall[index];
int temp = redBall[index];
redBall[index] = redBall[redBall.length-1-i];
redBall[redaBall.length-1-i] = temp;
}
}
}
标签：java,nums,int,System,冒泡排序,正三角形,num,static,public 来源： https://blog.csdn.net/xy294636185/article/details/101419966