1.奇数求和
/*
编写程序求1+3+5+...+99的和值
有一个数据从0变到100 循环 int i = 0; ,+100 ++
从0-100，范围内找到奇数 数%2==1 奇数
所有的奇数求和
需要变量，保存奇数的求和
实现步骤：
1.程序中可以使用的数据，预先定义好变量
需要奇数和
2.利用循环，让变量从0变化到100
3.判断变量的变化情况是不是奇数
4.如果是奇数和预先定义好的变量相加
*/
public class Test{
public static void main(String[] args){
//求出100内的奇数和,每一个奇数之间，前一个比后一个小2
//方法1
int sum = 0;
for(int i = 1; i < 100 ; i+=2){
sum += i;
}
System.out.println(sum);
//方法2
//定义变量，保存求和的值
sum = 0;
//for循环，循环中的变量，0-100
for(int i = 0 ;i < 100;i++){
if(i%2==1){
//对循环的变量，进行奇数的判断，i%2==1
sum += i;
}
}
System.out.println(sum);
}
}运行结果：
2.水仙花
/*
要求：计算水仙花数
三位数 100-999 个位数的立方+十位数的立方+百位数的立方 ==自己本身
153 = 1*1*1 +5*5*5 + 3*3*3
已知三位数 123 获取出每个数位 利用除法取模运算
实现步骤：
1.定义变量才存储 三个数位上的整数
2.利用循环，循环中的变量，从100变化到999
3.循环中得到三位数，利用算法，拆解成三个单独的数位
4.将三个数位立方的求和计算，计算后的求和 和它自己比较判断
如果相同，就是水仙花
*/
public class LoopTest_1{
public static void main(String[] args){
//定义三个变量
int ge = 0,shi = 0,bai = 0;int sum = 0;
//循环，循环变量从100-999
for(int i = 100 ; i <= 999 ; i++){
//获取百威
ge = i%10;
//获取各位
shi = (i/10)%10;
//获取个位
bai = i/100;
//对三个数位进行立方求和
//System.out.println(ge+" "+shi+" "+bai);
sum =ge*ge*ge+shi*shi*shi+bai*bai*bai;
//System.out.println(sum);
if(i == sum){
System.out.println("满足条件的数："+i);
}
}
}
}运行结果：
3.打印乘法口诀
/*
打印乘法口诀
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
乘法口诀需要利用双循环
for(int i = 1;i <=9 ;i++)这是控制行数 9行
for（int j = 1; j <=i ;j++）这是控制每行的个数 逐行增加
*/
public class LoopTest_3{
public static void main(String[] args){
for(int i = 1;i < 10; i ++){
for(int j = 1; j <= i; j++){
System.out.print(i+"*"+j+"="+i*j+" ");
}
System.out.println();
}
}
}运行结果：
4.利用方法打印数组
/*
定义方法，实现数组的遍历
遍历中输出结果 [11，33, 56，77,89]
实现步骤：
1.先定义一个方法实现数组的遍历
2.先打印[
3.遍历数组
输出数组的元素和逗号
判断是否遍历到了数组的最后一个元素，如果是
输出]中括号
*/
public class ArrayMethodTest{
public static void main(String[] args){
//定义一个数组
int[] arr = {11,33,56,77,89};
printArray(arr);
}
/*
定义方法，实现功能
返回值：void
方法参数：数组
*/
public static void printArray(int[] arr){
//先输出一半括号
System.out.print("{");
//遍历数组
for(int i = 0 ;i < arr.length ; i++){
//如果是最后一个元素就输出元素和另外一半括号
if(i == arr.length -1){
System.out.print(arr[i]+"}");
}
else System.out.print(arr[i]+",");
}
System.out.println();
}
}运行结果：
5.逆序输出数组（不等于 反向输出数组）
/*
素组的逆序:
数组中的元素，进行位置上的交换
逆序 不等于 反向遍历
就是数组中最远的两个索引，进行位置交换，实现数组的逆序
使用的是数组的指针思想，就是变量，思想可以随时变换索引
反转 reverse
实现步骤：
1.定义方法，实现数组的逆序
2.遍历数组
实现数组的最远索引换位置
使用临时的第三方变量
*/
public class ArrayMethodTest_1{
public static void main(String[] args){
int [] arr = {1,2,3,4,8,7};
printArray(arr);
reverse(arr);
printArray(arr);
}
/*
定义方法，实现数组的逆序
返回值：没有返回值
参数：数组就是参数
*/
public static void reverse(int[] arr){
//利用循环，实现数组遍历，遍历过程中，最远端换位
//for的第一项，定义2个变量
for(int min = 0, max = arr.length -1; min < max ; min++,max--){
//对数组中的元素进行位置交换
//min索引和max索引的元素交换
int temp = arr[min];
//max索引上的元素赋值给min索引
arr[min] = arr[max];
//临时变量，保存的数据，赋值到max索引上
arr[max] = temp ;
}
}
/*
定义方法，实现功能
返回值：void
方法参数：数组
*/
public static void printArray(int[] arr){
//先输出一半括号
System.out.print("{");
//遍历数组
for(int i = 0 ;i < arr.length ; i++){
//如果是最后一个元素就输出元素和另外一半括号
if(i == arr.length -1){
System.out.print(arr[i]+"}");
}
else System.out.print(arr[i]+",");
}
System.out.println();
}
}运行结果：
6.选择排序（素组的每个元素进行比较）
/*
数组的排序：一般都是升序排序，元素，小到大的排序
两种排序的方式
选择排序：素组的每个元素进行比较
冒泡排序：素组中相邻元素进行比较
规则：比较大小，位置交换
*/
public class ArrayMethodTest_2{
public static void main(String[] args){
int [] arr = {9,2,6,4,8,7};
printArray(arr);
selectSort(arr);
printArray(arr);
}
/*
定义方法，实现数组的选择排序
返回值;没有
参数：数组
实现步骤：
1.嵌套循环实现排序
外循环：控制的是一共比较了多少次
内循环：控制的是每次比较多少个元素
2判断元素的大小值
小值， 存储到小的索引中
*/
public static void selectSort(int[] arr){
for(int i = 0;i < arr.length -1; i++){
//内循环，是每次豆子减少，修改变量的定义
for(int j = i+1 ; j < arr.length ;j++){
//数组的元素进行判断
if(arr[i] > arr[j]){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
/*
定义方法，实现功能
返回值：void
方法参数：数组
*/
public static void printArray(int[] arr){
//先输出一半括号
System.out.print("{");
//遍历数组
for(int i = 0 ;i < arr.length ; i++){
//如果是最后一个元素就输出元素和另外一半括号
if(i == arr.length -1){
System.out.print(arr[i]+"}");
}
else System.out.print(arr[i]+",");
}
System.out.println();
}
}输出的结果：
7.冒泡排序和折半查找
/*
数组的查找功能：
在一个数组中，找一个元素，是否存在于数组中，如果存在，就返回索引
普通查询：
找到元素在数组中出现的索引，如果没有这个元素，结果就是负
*/
public class ArrayMethodTest_3{
public static void main(String[] args){
int [] arr ={8,5,7,2,9,3,4};
printArray(arr);
//调用冒泡排序
bubbleSort(arr);
printArray(arr);
int index =binarySearch(arr,9);
System.out.println(index);
}
/*
定义方法，实现折半查找
返回值：索引
参数：数组被查找的元素
实现步骤：
1.需要的变量三个，定义三个变量
2.进行循环折半，可以折半的条件 min<max
3让被找元素和中间索引元素进行比较
元素 > 中间索引 小指针 =中间 +1
元素 < 中间索引 大指针 =中间 -1
元素 ==中间索引 找到了，借宿了，返回中间索引
4.循环结束，无法折半
元素没有找到，返回-1
*/
public static int binarySearch(int[] arr,int key){
//定义三个指针变量
int min = 0;
int max = arr.length-1;
int mid = 0;
while(min <=max){
//公式计算中间索引
mid = (min + max)/2;
//让被找元素和中间索引元素进行比较
if(key > arr[mid]){
min = mid +1;
} else if(key < arr[mid]){
max = mid -1;
} else {
return mid;
}
}
return -1;
}
/*
定义方法，实现数组的冒泡排序
返回值：没有
参数：数组
实现步骤：
*/
public static void bubbleSort(int[] arr){
for(int i = 0 ; i < arr.length-1 ;i++){
for(int j = 0;j < arr.length-i-1; j++){
if(arr[j] > arr[j+1]){
int temp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = temp;
}
}
}
}
/*
定义方法，实现功能
返回值：void
方法参数：数组
*/
public static void printArray(int[] arr){
//先输出一半括号
System.out.print("{");
//遍历数组
for(int i = 0 ;i < arr.length ; i++){
//如果是最后一个元素就输出元素和另外一半括号
if(i == arr.length -1){
System.out.print(arr[i]+"}");
}
else System.out.print(arr[i]+",");
}
System.out.println();
}
}输出结果是：
