将四个整数进行从小到大的顺序排列 java_07_Java基础语法_第7天（练习）_讲义(练习加强+在eclipse中实现)...
第7天 Java基礎語法
今日內容介紹
? 循環練習
? 數組方法練習
第1章 循環練習
1.1 編寫程序求 1+3+5+7+……+99 的和值。
題目分析：
通過觀察發現，本題目要實現的奇數(范圍1-100之間)的累加和。
為了記錄累加和的值，我們需要定義一個存儲累加和的變量
我們要獲取到1-100范圍內的數
判斷當前數是否為奇數，是奇數，完成累加和操作
累加完畢后，最終顯示下累加和的值
解題步驟：
定義一個用來記錄累加和的變量
使用for循環語句，完成1-100之間每個數的獲取
使用if條件語句，判斷當前數是否是奇數，是奇數，進行累加和操作
使用輸出語句，打印累加和變量的值
/*
* 1.1編寫程序求 1+3+5+7+……+99 的和值
* 實現步驟：
* 1.定義一個用來記錄累加和的變量sum
* 2.使用for循環,完成1-100之間每個奇數的獲取
* 采用for(int i = 1; i < 100; i += 2)
* 3.在for循環中,與sum進行累加,求和
* 4.使用輸出語句,打印累加和變量的值sum
*/
public class LoopTest {
public static void main(String[] args) {
//1.定義一個用來記錄累加和的變量sum
int sum = 0;
//2.使用for循環,完成1-100之間每個奇數的獲取
for (int i = 1; i < 100; i += 2) {
//3.在for循環中,與sum進行累加,求和
sum += i;
}
//4.使用輸出語句,打印累加和變量的值sum
System.out.println("1-100之間的奇數累加和:" + sum);
}
}
1.2 輸出所有的水仙花數，所謂水仙花數是指一個數3位數，其每位數字立方和等于其本身，如153 = 111 + 333 + 555
題目分析：
通過觀察發現，本題目要實現打印符合要求的數字(即水仙花數)。
明確什么樣的數就是水仙花數。水仙花數是指一個3位數(100-999之間)，其每位數字立方之和等于該3位數本身。如153 = 111 + 333 + 555，
即 3位數本身 = 百位數立方 + 十位數立方 + 個位數立方;
獲取水仙花范圍內的所有3位數(100-999之間的每個3位數)
判斷該3位數是否滿足水仙花數，滿足，打印該3位數
解題步驟：
使用for循環，得到100-999之間的每個3位數
獲取3位數中百位數字、十位數字、個位數字
使用if條件語句，判斷該3位數是否滿足水仙花數，滿足，使用輸出語句，打印該3位數
/*
* 1.2輸出所有的水仙花數，所謂水仙花數是指一個數3位數，其每位數字立方和等于其本身，
* 如153 = 1*1*1 + 3*3*3 + 5*5*5
* 實現步驟：
* 1.定義變量存儲 三個數位的整數int
* 2.利用循環,循環中的變量,從100變化到999
* 3.在循環中得到的三位數,拆解成三個獨立的數位
* 4.將三個數位的各自立方求和計算,求和后的數,用if條件語句
* 與她自己進行匹配,符合就是水仙花數,否則繼續循環遍歷
* 5.當找到水仙花數,用輸出打印該水仙花數
*/
public class LoopTest1 {
public static void main(String[] args) {
//1.定義變量存儲 三個數位的整數int
int bai = 0;
int shi = 0;
int ge = 0;
//2.利用循環,循環中的變量,從100變化到999
for (int i = 100; i <= 999; i++) {
//3.在循環中得到的三位數,拆解成三個獨立的數位
bai = i / 100;
shi = i / 10 % 10;
ge = i % 10;
//4.將三個數位的各自立方求和計算,求和后的數,用if條件語句
// 與她自己進行匹配,符合就是水仙花數,否則繼續循環遍歷
if(bai * bai * bai + shi * shi * shi + ge * ge * ge == i){
//5.當找到水仙花數,用輸出打印該水仙花數
System.out.println("水仙花數:" + i);
}
}
}
}
1.3 ASCII編碼表
American Standard Code for Information Interchange，美國標準信息交換代碼.
數字0-9對應ASCII編碼十進制為48-57, 字母a-z對應ASCII編碼十進制為97-122，字母A-Z對應ASCII編碼十進制為65-90
/*
* 1.3 char類型存儲
* 數字0-9對應ASCII編碼十進制為48-57,
* 字母a-z對應ASCII編碼十進制為97-122，
* 字母A-Z對應ASCII編碼十進制為65-90
* a.取值范圍
* short:占兩個字節,是有符號數據,取值范圍-2^15 - 2^15 (-32767-32767)
*char：占兩個字節,是無符號數據,取值范圍0-2^16(0-65536)
* b.類型轉換
* char類型的數據參加運算時,需要轉換成int數據類型
* c.案例代碼
* ASCII編碼表演示
* 字符JAVA 數據類型,char
* 整數JAVA 數據類型,int
*
* int類型 和char數據類型轉換
* char兩個字節,int四個字節
*
* char轉成int數據類型的時候,類型自動提升,char數據類型,會查詢編碼表,得到整數
* int轉成char類型的時候,需要強制類型轉換,會查詢編碼表
*
* char存儲漢字,查詢Unicode編碼表
*
* char可以和int計算,提升為int類型,內存中兩個字節
*
*/
public class LoopTest2 {
public static void main(String[] args) {
char c = 'a';
int i = c + 1;
System.out.println(i);
int j = 90;
char h = (char) j;
System.out.println(h);
System.out.println((char)6);
char k = '你';
System.out.println(k);
//char m = -1;
}
}
1.4 利用for循環打印ABCDEFG…XYZ，26個大寫字母與26個小寫字母
題目分析：
通過觀察發現，本題目要實現打印26個大寫字母、26個小寫字母
一共26個大小寫字母，那么，可以考慮循環26次。在每次循環中，完成指定字母的大小寫打印
找出ABCDEFG…XYZ這些字母之間的變化規律
通過ASCII表發現，后面的字母比它前面的字母，ASCII值大1
下一個字母 = 上一個字母 + 1
如： A B C D
65 66 67 68
在每次循環中打印上一個字母大小寫，并指定下一個字母
解題步驟：
定義初始化大寫變量，值為’A’； 初始化小寫變量，值為’a’
使用for循環，進行26次循環
在每次循環中，打印大寫字母、小寫字母。
每次打印完成后，更新大寫字母值、小寫字母值
/*
* 1.4利用for循環打印ABCDEFG...XYZ，26個大寫字母與26個小寫字母
* 實現步驟：
* 1.定義初始化大寫變量,值為'A';初始化小寫變量,值為'a'
* 2.使用for循環,進行26次循環
* 3.在每次循環的過程中,打印大寫字母和小寫字母(與此同時,更新大寫字母,小寫字母)
*/
public class LoopTest3 {
public static void main(String[] args) {
//1.定義初始化大寫變量,值為'A';初始化小寫變量,值為'a'
char da = 'A';
char xiao = 'a';
//2.使用for循環,進行26次循環
for (int i = 0; i < 26; i++) {
//3.在每次循環的過程中,打印大寫字母和小寫字母(與此同時,更新大寫字母,小寫字母)
System.out.println("大寫字母:" + da + " 小寫字母:" + xiao);
da++;
xiao++;
}
}
}
1.5 利用for循環打印 9*9 表?
如：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
import java.util.Scanner;
/*
* 1.5利用for循環打印 9*9 表?
* 實現步驟：
* 1.定義一個外層for循環,初始值從1開始,循環9次,用來控制打印的行數
* 2.在外層for循環內部,定義一個for循環,
* 初始值從1開始,循環次數與當前行數相等,用來完成每行打印指定次數的乘法公式
* 3.在內層for循環中,完成每行指定次數的乘法公式打印
* 4.在外層for循環中,當每行指定次數的乘法公式打印完畢后,通過System.out.println();切換到下一行
* 這樣,再次打印乘法公式時,就在下一行輸出打印了
*/
public class LoopTest4 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//打印n * n乘法表
System.out.println("請輸入你想打印乘法表的維數:");
int index = sc.nextInt();
System.out.println("如下打印:" + index + " * " + index + " 乘法表");
print99(index);
}
public static void print99(int index){
//1.定義一個外層for循環,初始值從1開始,循環index次,用來控制打印的行數
for (int i = 1; i <= index; i++) {
//2.在外層for循環內部,定義一個for循環
for (int j = 1; j <= i; j++) {
//3.在內層for循環中,完成每行指定次數的乘法公式打印
System.out.print(j + " * " + i + " = " + i * j + "\t");
}
//4.在外層for循環中,當每行指定次數的乘法公式打印完畢后,通過System.out.println();
System.out.println();
}
}
}
第2章 數組方法練習
2.1 定義打印數組元素方法,按照給定的格式打印[11, 33, 44, 22, 55]
題目分析：
通過觀察發現，本題目要實現按照指定格式，打印數組元素操作
通過循環，我們可以完成數組中元素的獲取，數組名[索引]
觀察發現，每個數組元素之間加入了一個逗號”,”進行分隔；并且，整個數組的前后有一對中括號”[]”包裹數組所有元素。
解題步驟：
使用輸出語句完成打印 左邊的中括號”[”
使用循環，輸出數組元素值。輸出元素值分為兩種情況，如下：
a) 最后一個數組元素，加上一個右邊的中括號”]”
b) 非最后一個數組元素，加上一個逗號”,”
/*
* 2.1定義打印數組元素方法,按照給定的格式打印[11, 33, 44, 22, 55]
* 實現步驟：
* 1.定義方法實現數組的遍歷
* 2.先打印括號--[
* 3.遍歷數組
* 判斷是否遍歷到了數組的最后一個元素,如果是最后一個元素,輸出括號]
* (這里打印最后一個元素需要換行,保證下次調用方法,不會顯示在同一行,
* 否則:輸出數組的元素和逗號(這樣打印元素,不需要換行,保證元素顯示在同一行))
*/
public class ArrayMethodTest {
public static void main(String[] args) {
//1.定義一個數組
int[] arr = {11, 33, 44, 22, 55};
print(arr);
}
/*
* 定義方法實現數組的遍歷
* 返回值：void
* 參數：數組
*/
public static void print(int[] arr){
//1.打印括號[ 不要換行
System.out.print("[");
//2.遍歷數組
for(int i = 0; i < arr.length; i++){
//3.判斷是否遍歷了數組的最后一個元素,如果是最后一個元素,輸出括號]
if(i == arr.length -1){
//3.1.這里打印最后一個元素需要換行,保證下次調用方法,不會顯示在同一行
System.out.println(arr[i] + "]");
}else{
//3.1.2這樣打印元素,不需要換行,保證元素顯示在同一行
System.out.print(arr[i] + ",");
}
}
}
}
2.2 數組元素逆序
/*
* 2.2數組元素逆序
* 實現步驟：
* 1.利用for循環,實現數組遍歷,遍歷過程中,最遠端換位
* 2.for的第一項,定義兩個變量,判斷條件：min <= max,增量min++,max--
* min索引和max索引的元素進行交換
* (使用臨時的第三方變量進行換成min索引對應元素,之后在賦值給max索引對應元素)
*/
public class ArrayMethodTest1 {
public static void main(String[] args) {
//1.定義一個數組
int[] arr = {11, 33, 44, 22, 55};
//2.先打印一把數組,看數組正常
print(arr);
//3.將數組逆序
reverse(arr);
//4.查看數組逆序后的情況
print(arr);
}
/*
* 定義方法實現數組的遍歷
* 返回值：void
* 參數：數組
*/
public static void print(int[] arr){
//1.打印括號[ 不要換行
System.out.print("[");
//2.遍歷數組
for(int i = 0; i < arr.length; i++){
//3.判斷是否遍歷了數組的最后一個元素,如果是最后一個元素,輸出括號]
if(i == arr.length -1){
//3.1.這里打印最后一個元素需要換行,保證下次調用方法,不會顯示在同一行
System.out.println(arr[i] + "]");
}else{
//3.1.2這樣打印元素,不需要換行,保證元素顯示在同一行
System.out.print(arr[i] + ",");
}
}
}
/*
* 定義方法,實現數組的逆序
* 返回值：void
* 參數:數組
*/
public static void reverse(int[] arr){
//利用循環,實現數組遍歷,遍歷過程中,最遠端換位
//for的第一項,定義兩個變量
for (int min = 0,max = arr.length -1; min <= max; min++,max--) {
//對數組中的元素,進行位置交換
//min索引和max索引的元素進行交換
//定義變量,保存min索引
int temp = arr[min];
//max索引上的元素,賦值給min索引
arr[min] = arr[max];
//將臨時變量中緩存的數據,賦值給max序列
arr[max] = temp;
}
}
}
2.3 數組元素選擇排序
/*
* 數組的排序：一般是升序,元素,從小到大的排列
*
* 兩種排序的方式：
* 選擇排序:數組的每個元素都進行比較
* 冒泡排序:數組中的相鄰元素進行比較
* 規則:比較大小,位置交換
*
*/
public class ArrayMethodTest2 {
public static void main(String[] args) {
//1.給定一個需要排序的數組
int[] arr = {3,1,5,-8,0,9,2};
//2.調用選擇排序方法
selectSort(arr);
//3.實現數組的遍歷打印
print(arr);
}
/*
* 定義方法實現數組的選擇排序
* 返回值：void
* 參數：數組
*/
public static void selectSort(int[] arr){
//外循環,選擇排序,外循環需要arr.length-1次數
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 print(int[] arr){
//1.打印括號[ 不要換行
System.out.print("[");
//2.遍歷數組
for(int i = 0; i < arr.length; i++){
//3.判斷是否遍歷了數組的最后一個元素,如果是最后一個元素,輸出括號]
if(i == arr.length -1){
//3.1.這里打印最后一個元素需要換行,保證下次調用方法,不會顯示在同一行
System.out.println(arr[i] + "]");
}else{
//3.1.2這樣打印元素,不需要換行,保證元素顯示在同一行
System.out.print(arr[i] + ",");
}
}
}
}
2.4 數組元素冒泡排序
/*
* 數組的冒泡排序法:數組的相鄰元素進行比較大小,交換位置
* N個數字要排序完成，總共進行N-1趟排序，每i趟的排序次數為(N-i-1)次(i = 0,1,2)
* 所以可以用雙重循環語句，外層控制循環多少趟，內層控制每一趟的循環次數
* 實現步驟：
* 1.進行外循環,冒泡排序,外循環需要arr.length-1次數
* 2.進行內循環,內循環進行相鄰元素大小比較,根據升序交換位置,內循環結束一趟,出來一個最大值
* 等又一次外循環,已經出來的最大的數,就無需進行納入比較中,但是,其他繼續相鄰元素比較大小,
* 直至所有最大的數出來
*/
public class ArrayMethodTest3 {
public static void main(String[] args) {
//1.給定一個需要排序的數組
int[] arr = {3,1,5,-8,0,9,2};
//2.調用冒泡排序方法
bubbleSort(arr);
//3.實現數組的遍歷打印
print(arr);
}
/*
* 冒泡排序法
* 返回值：void
* 參數：數組
* N個數字要排序完成，總共進行N-1趟排序，每i趟的排序次數為(N-i-1)次 (i = 0,1,2)
*/
public static void bubbleSort(int[] arr){
//1.進行外循環,冒泡排序,外循環需要arr.length-1次數,總共進行N-1趟排序
for(int i = 0; i < arr.length - 1; i++){
//2.進行內循環,內循環進行相鄰元素大小比較,每i趟的排序次數為(N-i-1)次
//故內循環：判斷條件為：j < arr.length - 1 - i
for(int j = 0; j < arr.length - 1 - i;j++){
//3.根據升序交換位置
if(arr[j] > arr[j+1]){
//4.進行交換數組中的元素位置
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
/*
* 定義方法實現數組的遍歷
* 返回值：void
* 參數：數組
*/
public static void print(int[] arr){
//1.打印括號[ 不要換行
System.out.print("[");
//2.遍歷數組
for(int i = 0; i < arr.length; i++){
//3.判斷是否遍歷了數組的最后一個元素,如果是最后一個元素,輸出括號]
if(i == arr.length -1){
//3.1.這里打印最后一個元素需要換行,保證下次調用方法,不會顯示在同一行
System.out.println(arr[i] + "]");
}else{
//3.1.2這樣打印元素,不需要換行,保證元素顯示在同一行
System.out.print(arr[i] + ",");
}
}
}
}
2.5 數組元素普通查找
2.6 數組元素二分查找(折半查找)
/*
* 二分查找法：
* 在一個數組中,找到一個元素,是否存在于數組中,如果存在,就返回索引
*實現步驟：
*1.三個指針變量mid min max
*2.進行循環折半：可以折半的條件min <= max (需要用到的循環體是while循環體-因為不知道具體需要多少次遍歷)
*3.循環體中,公式計算中間索引
*4.循環體中,讓被查找的元素與中間的索引所對應的元素進行比較：
*4.1.key < arr[mid]： max = mid - 1
*4.2.key > arr[mid]: min = mid + 1
*4.3.key == arr[mid]:return mid
*5.若循環體結束,元素沒有找到,沒有找到索引,需要返回-1,代表元素沒有找到
* 普通查詢法:
* 找到元素在數組中出現的索引,如果沒有這個元素,結果就是負數
*/
public class findArrayTest {
public static void main(String[] args) {
//1.給定一個已經排好序的數組
int[] arr = {1,2,3,4,5};
//2.調用二分查找法
int index = binarySearch(arr,4);
if(index != -1){
System.out.println("數組中查找到該元素,該元素的索引為:" + index);
}else{
System.out.println("數組中沒有找到該元素！");
}
//3.普通查詢
int index1 = search(arr,4);
if(index1 != -1){
System.out.println("數組中查找到該元素,該元素的索引為:" + index1);
}else{
System.out.println("數組中沒有找到該元素！");
}
}
/*
* 定義方法,實現折半查找
* 返回值:索引
* 參數：數組,需要查找的元素
*/
public static int binarySearch(int[] arr,int key){
//1.三個指針變量mid min max
int min = 0;
int max = arr.length - 1;
int mid = 0;
//2.進行循環折半：可以折半的條件min <= max (需要用到的循環體是while循環體-因為不知道具體需要多少次遍歷)
while(min <= max){
//3 公式計算中間索引
mid = (min + max) / 2;
//4.循環體中,讓被查找的元素與中間的索引所對應的元素進行比較：
if(key < arr[mid]){
//4.1.key < arr[mid]： max = mid - 1
max = mid - 1;
}else if(key > arr[mid]){
//4.2.key > arr[mid]: min = mid + 1
min = mid + 1;
}else{
//4.3.key == arr[mid]:return mid
return mid;
}
}
//5.循環體結束,元素沒有找到,需要返回-1,代表元素沒有找到
return -1;
}
/*
* 定義方法，實現數組的普通查詢
* 返回值:索引int
* 參數:數組,查找的元素
* 實現步驟：
* 1.for循環遍歷數組
* 2.遍歷過程中,遍歷數組中的元素與查找的元素進行比較
* 符合:返回索引
* 不符合:繼續遍歷數組,直至結束
* 3.若遍歷結束,沒有找到索引,返回-1,代表數組中沒有該元素
*/
public static int search(int[] arr,int key){
//1.for循環遍歷數組
for (int i = 0; i < arr.length; i++) {
//2.遍歷過程中,遍歷數組中的元素與查找的元素進行比較
if(arr[i] == key){
return i;
}
}
//3.若遍歷結束,沒有找到索引,返回-1,代表數組中沒有該元素
return -1;
}
}
總結
以上是生活随笔為你收集整理的将四个整数进行从小到大的顺序排列 java_07_Java基础语法_第7天（练习）_讲义(练习加强+在eclipse中实现)...的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： java水晶报表pull模式_水晶报表p
- 下一篇： attribute java c_属性别