Java邏輯思維題

原創 会上网的蜘蛛 2020-07-07 06:50

Java面試題合解

  1. 聲明兩個變量，將兩個變量我得值進行交換，並打印出交換後的結果。

    public static void main(String[] args){
    int a, b;
    a = 10;
    b = 20;
    int c;//用於數據的中間交換
    c = a;
    a = b;
    b = c;
    System.out.println("a的值爲：" + a);
    System.out.println("b的值爲：" + b);
}

  2. 給a,b,c分別賦值，判斷a是否比b,c都大。

public static void main(String[] args){
    int a = 10;
    int b = 30;
    int c = 40;
    boolean abc = a>b&&a>c;
    System.out.println("a比b和c都大是" + abc);
}
  1. 問System.out.println(1<2?3:1.2);的結果是多少

答：3.0

解析:三木運算的運算結果只能是一個，所以要有一個變量類型要將3和1.2同時放進去，所以這個變量需要的是一個double類型，所以結果比應該是3，而是3.0。

  1. 使用for循環，打印出0-100所有的3的倍數之和
public static void main(String[] args){
    int sum = 0;
    for(int i = 0;i < 100;i++){
        if(i % 3 == 0){//如果是3的倍數進行累加
            sum += i;
        }
    }
    System.out.println(sum);
}
  1. 打印乘法口訣
public static void main(String[] args){
    for(int i = 1;i <= 9;i ++){//外部循環打印每一行
        int j;
        for(j = 0;j <= i;j++){//內部循環打印每一列
            System.out.print(i + "*" + j + "=" + (i * j) + " ");
        }
        System.out.println();//換行
    }
}
  1. 如果一個數等於它的因子之和，我們稱這個數爲完數，例如6的因子爲1,2,3;1+2+3=6,所以6就是一個完數。打印出1000以內所有的完數。
public static void main(String[] args){
    for(int i = 0;i < 1000;i++){//外部循環遍歷1000
        //12 --- 1 2 3 4 6 
        int sum = 1;//用於記錄每一個數的因子之和
        for(int j = 2;j < i;j++){//內部循環遍歷因數
            if(i % j == 0){//整除即爲因數
                sum += j;
            }
        }
        if(sum == i){//判斷題目要求
            System.out.println(i + "是完數");
        }
    }
}

求一個數的所有的因數和的時候，不妨設置變量存儲的初始值爲1，那麼就可以不用除以1了。

  1. 求出1000以內的素數。
public static void main(String[] args){
    for(int i = 2;i<1000;i++){
        int j;
        boolean tt = true;
        for(j = 2;j < i;j++){
            if(i % j == 0){
                tt = false;
            }
        }
        if(tt == true){
            System.out.println(i + "是素數");
        }
    }
}

定義一個標識來標識素數，如果標識改變，則不是素數，標識不改變可以繼續遍歷。

  1. 聲明double類型的數組，並賦值，打印出第二個、第四個元素的值。
public static void main(String[] args){
    double[] arr = {1,2,3,4,5,6};
    System.out.println(arr[2]);
    System.out.println(arr[4]);
}
  1. 聲明一個長度爲12，數值爲0-20的隨機數的數組。
public static void main(String[] args){
    int[] arr = new int[12];
    for(int i = 0; i<12;i++){
        arr[i] = (int)(Math.random*21);//長度爲0-21的隨機長度
        System.out.println(arr[i]);
    }
}
  1. 聲明一個隨機長度的數組，使用2-100以內的偶數賦值，獲取數組的最大值和最小值,打印出兩者的下標和數值,將兩者的位置進行互換。
import java.util.*;

public class Mode5 {
	public static void main(String[] args) {
		int Mlength = (int) (Math.random() * 30 + 10);
		int[] arr = new int[Mlength];
		int max = 0;
		int min = 0;
		int max_index = 0;
		int min_index = 0;
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) ((Math.random() * 50 + 1) * 2);
		}
		System.out.println(Arrays.toString(arr));
		for (int i = 0; i < arr.length; i++) {
			max = arr[0];
			if (max > arr[i]) {
				max = arr[i];
				max_index = i;
			} else if (min < arr[i]) {
				min = arr[i];
				min_index = i;
			}
		}
		System.out.println("最小值的下標" + max_index + "，這個數是" + max);
		System.out.println("最大值的下標" + min_index + "，這個數是" + min);
		arr[min_index] = max;
		arr[max_index] = min;
		System.out.println(Arrays.toString(arr));
	}
}
  1. 去除數組(1,3,1,4,2,3,6,1,5)中的重複項存入一個新的數組

思路：取出原數組的數據跟新的數組的數據進行對比；根源數據進行對比的題目要設定一個標識，用於標識不滿足條件的東西。

public static void main(String[] args){
    int[] arr1 = {1,3,1,4,2,3,6,1,5};
    boolean temp = true;
    int arr2 = new int[arr1.length];
    int index = 0;
    for(int i = 0 ; i<arr1.length;i++){
        for(int j = 0;j<arr2.length;j++){
            if(arr2[j] == arr1[i]){
                //這裏說明數據已經重複就要終止循環。
                temp = false;
                break;
            }
        }
        //這裏進行判斷
        //下標不能是i，所以要新定義一個下標，index記錄下標。
        //只有在判斷成功後，新的元素存入了新的數組index才能加一。
        if(temp == true){
            arr2[index] = arr1[i];
            index ++;
        }
    }
    for(inde i = 0;i <arr2.length;i++){
        System.out.print(arr2[i]);
    }
}

這個題和上面的第七題有異曲同工之處，要和原來的數組進行比較是否有重複的或者沒有重複的，都要設定一個布爾值就行標識，當條件不滿足時，布爾值發生變化，終止循環，否則爲滿足條件，進行判斷，得出結果。

遇到和之前的數據進行相比的題目要設定一個boolean類型的值。

這樣的話我們會發現數組初始化他的每一個值的默認值爲0，所以如果原數組中有0的話新的0就沒有辦法插入到新的數組中。

  1. 去除數組(1,3,0,1,4,2,3,6,1,5)中的重複項存入一個新的數組

思路：上一題因爲第二個數組每一次都遍歷了，所以這裏就會出現重複的工作，所以這裏可以取出第一個數組的數據跟第二個數組的以存放的數據進行比較，但是在開始的時候會出現存放的數據爲0，所以剛開始循環的時候應該講第一個元素直接放入第二個數組中。

public static void main(String[] args){
    int[] arr1 = {1,3,0,1,4,2,3,6,1,5};
    int[] arr2 = new int[arr1.length];
    boolean temp = true;//標識
    int index = 0;//記錄新數組的索引值
    for(int i = 0;i<arr1.length;i++){
    	if(i == 0){//新數組的第一個元素肯定是唯一的，所以直接放入
            arr2[index] = arr1[i];
            index ++;
        }else{//其他的元素按照老的數組取出的元素和新數組的數據進行對比
     		for(int j = 0;j<index;j++){
                if(arr1[i] == arr2[j]){
                    temp = false;
                    //出現了相同元素終止循環
                    break;
                }
            }    
            if(temp == true){//判斷標識是否爲true，滿足條件即可存入
                arr2[index] = arr1[i];
                index ++;
            }
        }
    }
    for(int i = 0;i<arr2.length;i++){
        System.out.println(arr2[i]);
    }
}
  1. 去除數組{1, 2, 3, 4, 8, 6, 5, 0, 4, 6, 0, 6, 3, 4, 5, 3, 6, 0, 8}中的0項，並將其他元素存入新的數組。
public class Mode {
	public static void main(String[] args) {
		// 去除數組中的0項並將其他元素存入一個數組
		// 判斷重複定義一個布爾值，用於判定條件是否滿足
		// 新數組的索引要用新的整形索引進行標識
		int[] arr = { 1, 2, 3, 4, 8, 6, 5, 0, 4, 6, 0, 6, 3, 4, 5, 3, 6, 0, 8 };
		int[] arr1 = new int[arr.length];
		boolean temp = true;
		int index = 0;
		for (int i = 0; i < arr.length; i++) {
			temp = true;
			if (i == 0) {
				arr1[index] = arr[i];
				index++;
			} else {
				if (arr[i] == 0) {
					temp = false;
					continue;
				}
			}
			if (temp == true) {
				arr1[index] = arr[i];
				index++;
			}
		}
		for (int i = 0; i < arr1.length; i++) {
			System.out.print(arr1[i]);
		}
	}
}
  1. ****************************************************************************使用數組複製
//使用Arrays.copyOf()方法截取arr數組的前七個元素
public static void main(String[] args) {
	int[] arr1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 };
	int[] arr2 = new int[5];
	System.arraycopy(arr1, 1, arr2, 2, (int)(Math.random()*4));
	for (int i = 0; i < arr2.length; i++) {
		System.out.println(arr2[i]);
	}
}
//使用`System.arraycopy(arr1, 1, arr2, 2, 5)`
public static void main(String[] args){
    int[] arr1 = {1,2,3,4,5,6,7,8,9};
    int[] arr2 = new int[10];
    System.arraycopy(arr1, 1, arr2, 2, 5);
    for(int i = 0;i<arr2.length;i++){
        System.out.println(arr2[i]);
    }
}
  1. 二維數組初始化的數組個數是不可變的，但是子數組的長度是可以改變的。
public static void main(String[] args){
    int[][] arr1 = new int[4][5];
    int[] arr2 = new int[40];
    arr1[0] = arr2;
    for(int i = 0;i<arr1.length;i++){
        System.out.println(Array.toString(arr1[i]));
    }
}
  1. 聲明一個二維數組，使用循環給每個元素賦一個100以內隨機值，打印出每個子元素數組的最大值，打印出該二維數組的最大值。
import java.util.*;

public class Mode4 {
	public static void main(String[] args) {
		/* 聲明一個二維數組，使用循環給每個元素賦一個100以內隨機值，打印出每個子元素數組的最大值，打印出該二維數組的最大值。 */
		int[][] arr1 = new int[3][4];
		int max1 = 0;
		int max2 = 0;
		int max3 = 0;
		int max = 0;
		for (int i = 0; i < arr1.length; i++) {
			for (int j = 0; j < arr1[i].length; j++) {
				arr1[i][j] = (int) (Math.random() * 100);
			}
		}
		for (int i = 0; i < arr1.length; i++) {
			if (i == 0) {
				System.out.println("第一個數組開始判斷");
				for (int j = 0; j < arr1[i].length; j++) {
					max1 = max1 > arr1[i][j] ? max1 : arr1[i][j];
				}
				System.out.println("第一個數組判斷成功，最大值爲：" + max1);
			} else if (i == 1) {
				System.out.println("第二個數組開始判斷");
				for (int j = 0; j < arr1[i].length; j++) {
					max2 = max2 > arr1[i][j] ? max2 : arr1[i][j];
				}
				System.out.println("第二個數組判斷成功，最大值爲：" + max2);
			} else {
				System.out.println("第三個數組開始判斷");
				for (int j = 0; j < arr1[i].length; j++) {
					max3 = max3 > arr1[i][j] ? max3 : arr1[i][j];
				}
				System.out.println("第三個數組判斷成功，最大值爲：" + max3);
			}
		}
		max = max1 >= max2 ? max1 : max2;
		max = max >= max3 ? max : max3;
		System.out.println("三個最大之中最大的爲" + max);
	}
}
  1. 聲明一個二維數組，使用循環給每個元素賦一個100以內隨機值，打印出每個子元素數組的最大值，打印出該二維數組的最大值，並打印出該元素在第幾個數組中。
public class Mode4 {
	public static void main(String[] args) {
		/* 聲明一個二維數組，使用循環給每個元素賦一個100以內隨機值，打印出每個子元素數組的最大值，打印出該二維數組的最大值，並打印出該最大值在哪個子元素中。 */
		int[][] arr1 = new int[3][4];
		int max_p;
		for (int i = 0; i < arr1.length; i++) {
			for (int j = 0; j < arr1[i].length; j++) {
				arr1[i][j] = (int) (Math.random() * 100 + 1);
			}
			System.out.println(Arrays.toString(arr1[i]));
		}
		for (int i = 0; i < arr1.length; i++) {
			max_p = arr1[i][0];
			for (int j = 0; j < arr1[i].length; j++) {
				max_p = max_p > arr1[i][j] ? max_p : arr1[i][j];
			}
			System.out.println("第" + (i + 1) + "個元素是最大值，最大值爲：" + max_p);
		}
		int max = 0;
		int max_index = 0;
		for (int i = 0; i < arr1.length; i++) {
			max = arr1[0][0]; 
			for (int j = 0; j < arr1[i].length; j++) {
				if (max < arr1[i][j]) {
					max = arr1[i][j];
					max_index = i;
				}
			}
		}
		System.out.println("數組中的最大值爲：" + max);
		System.out.println("該最大值所在的子元素在" + (max_index + 1) + "箇中");
	}
}
  1. 聲明一個隨機長度的數組，使用2-100以內的偶數賦值，獲取數組的最大值和最小值, 打印出兩者的下標和數值, 將兩者的位置進行互換。
public static void main(String[] args){
    int Mlength = (int)(Math.random()*30+10);
    int[] arr = new int[Mlength];
    int max = 0;
    int min = 0;
    int max_index = 0;
    int min_index = 0;
    for(int i = 0;i<arr.length;i++){
        arr[i] = (int)((Math.random()*50+1) * 2);
    }
    for(int i = 0;i<arr.length;i++){
        if(max > arr[i]){
            max = arr[i];
            max_index = i;
        }
    	else if(min < arr[i]){
            min = arr[i];
            min_index = i;
        }
    }
    System.out.println("最大值的下標"+max_index+"，這個數是"+max);
    System.out.println("最大值的下標"+min_index+"，這個數是"+min);
    arr[max_index ] = min;
    arr[min_index] = max;
}
  1. 定義一個10*10的二維數組，使用隨機值進行賦值，對每一個子數組進行排序，對整個數組進行排序。
package Mode0;

import java.util.Arrays;

public class Mode1 {
	public static void main(String[] args) {
		int size = 10;
		int arr[][] = new int[size][size];
		setInt(arr);
		System.out.println("-----------------------------");
		System.out.println("內部排序");
		getInta(arr);
		System.out.println("-----------------------------");
		System.out.println("全排序");
		getNInta(arr);
	}

	// 賦值
	public static void setInt(int[][] arr) {
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr[i].length; j++) {
				arr[i][j] = (int) (Math.random() * 200 + 10);
			}
			System.out.println(Arrays.toString(arr[i]));
		}
	}

	// 內部排序
	public static void getInta(int[][] arr) {
		// 對內部排序
		for (int i = 0; i < arr.length; i++) {
			for (int k = 0; k < arr[i].length - 1; k++) {
				for (int j = 0; j < arr[i].length - 1 - k; j++) {
					if (arr[i][j] > arr[i][j + 1]) {
						arr[i][j] = arr[i][j] + arr[i][j + 1];
						arr[i][j + 1] = arr[i][j] - arr[i][j + 1];
						arr[i][j] = arr[i][j] - arr[i][j + 1];
					}
				}
			}
			System.out.println(Arrays.toString(arr[i]));
		}
	}

	public static void getN(int[][] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.println(Arrays.toString(arr[i]));
		}
	}

	// 全排序
	public static void getNInta(int[][] arr) {
		boolean bo = true;
		while (bo) {
			bo = false;
			el: for (int i = 0; i < arr.length; i++) {
				for (int j = 0; j < arr[i].length; j++) {
					// 到了最後結束全部的循環
					if (i == arr.length - 1 && j == arr[i].length - 1) {
						break el;
					}
					// 最結尾結束
					else if (j == arr[i].length - 1) {
						if (arr[i][j] > arr[i + 1][0]) {
							bo = true;
							arr[i][j] = arr[i][j] ^ arr[i + 1][0];
							arr[i + 1][0] = arr[i][j] ^ arr[i + 1][0];
							arr[i][j] = arr[i][j] ^ arr[i + 1][0];
						}
					}
					// 中間變換
					else if (arr[i][j] > arr[i][j + 1]) {
						bo = true;
						arr[i][j] = arr[i][j] + arr[i][j + 1];
						arr[i][j + 1] = arr[i][j] - arr[i][j + 1];
						arr[i][j] = arr[i][j] - arr[i][j + 1];
					}
				}
			}
		}
		getN(arr);
	}
}
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Java編程工具：簡潔高效實現

Java編程工具：簡潔高效實現Java編程工具：簡潔高效實現Java編程工具：簡潔高效實現

原創 2024-04-27 00:41:09

Java word通過html設置樣式（Spire Docx）

  Java  word通過html設置樣式（Spire Docx） <dependencies>   <!-- Apache POI dependency for Word --> <dependency>

原創 2024-04-26 23:42:09

從零開始學架構V2-初識架構設計-1

一、架構設計的主要目的 爲了解決軟件系統複雜度帶來的問題 二、複雜性來源 軟件的架構設計是一個非常複雜的過程；基於業務&技術現狀、公司成本、團隊規模、團隊技術能力、近三年業務發展規模預測、技術發展趨勢等條件篩選出合適的技術、編寫多種架構設計

原創 2024-04-25 23:56:25

高德地圖爬蟲實踐：Java多線程併發處理策略

背景介紹 高德地圖是一款基於互聯網和移動互聯網的地圖與導航應用，提供了包括地圖瀏覽、公交查詢、駕車導航、步行導航等在內的多種功能。其龐大的用戶羣體和豐富的地圖數據成爲了各行各業進行位置服務、地理信息分析等應用的首選。 爬蟲實踐需求 在

原創 2024-04-25 23:26:44

三十分鐘入門基礎Go（Java小子版）

前言 Go語言定義 Go（又稱 Golang）是 Google 的 Robert Griesemer，Rob Pike 及 Ken Thompson 開發的一種靜態、強類型、編譯型語言。Go 語言語法與 C 相近，但功能上有：內存安

原創 2024-04-25 23:17:43

流水線運行出錯排查難？AI 來幫你

“我的企業有幾千條流水線，每次流水線運行出錯，都要投入不少的技術人員進去排查，需要花費不少的時間。” 遇到這種情況，怎麼解決。在 AI 爆火的今天，AI 如何助力 DevOps 效率提升？ 雲效與阿里雲通義大模型合作，推出了流水線智能排查能

原創 2024-04-24 21:12:07

西安站開營！AI 編碼助手通義靈碼幫大學生“整活兒”

如何更好地與 AI 爲伴，做時代的先進開發者？4 月 17 日，阿里雲推出的 AI 編程助手通義靈碼與雲工開物“高校訓練營”走進西安多所高校開啓實操培訓，結合 AI 輔助編程的發展背景、通義靈碼的具體能力和應用實操，幫助在校大學生了解人工智

原創 2024-04-24 21:12:06

「Java開發指南」如何利用MyEclipse啓用Spring DSL？（二）

本教程將引導您通過啓用Spring DSL和使用Service Spring DSL抽象來引導Spring和Spring代碼生成項目，本教程中學習的技能也可以很容易地應用於其他抽象。在本教程中，您將學習如何： 爲Spring DSL初始化

原創 2024-04-24 11:35:31

Java中的複製

在Java中將一個對象的引用複製給另外一個對象，一共有三種方式：直接賦值，淺拷貝，深拷貝。這三種方式實際上都是拷貝對象。 直接賦值複製 直接賦值：如 A a1 = a2，我們需要理解的是這實際上覆制的是引用，也就是說 a1 和 a2 指

原創 2024-04-23 23:33:35

利用HttpClient庫下載螞蜂窩圖片

前言 網絡爬蟲技術作爲互聯網數據獲取的重要工具，在各行各業都有着廣泛的應用。而在本文中，我們將利用Java中的HttpClient庫，通過編寫一個簡單而有效的網絡爬蟲程序，實現下載螞蜂窩網站的圖片的功能。通過這個例子，我們不僅可以學習如

原創 2024-04-23 23:24:51

MySQL死鎖排查，原來我一直沒懂。。。

喜大普奔，微信給我的公衆號開了留言功能！！！有緣看到這篇文章的朋友，可以留個言互動下，謝謝～ 最近線上偶發MySQL的死鎖異常，發現原來很多理論都只背了個結論，細節都是魔鬼。 比如，MySQL在RR級別用gap lock防止幻讀，

原創 2024-04-23 23:10:58

一次Redis訪問超時的“捉蟲”之旅

01    引言 作爲後端開發人員，對Redis肯定不陌生，它是一款基於內存的數據庫，讀寫速度非常快。在愛奇藝海外後端的項目中，我們也廣泛使用Redis，主要用於緩存、消

原創 2024-04-23 13:04:36

日誌架構演進：從集中式到分佈式的Kubernetes日誌策略

當我們沒有使用雲原生方案部署應用時採用的日誌方案往往是 ELK 技術棧。 這套技術方案比較成熟，穩定性也很高，所以幾乎成爲了當時的標配。 可是隨着我們使用 kubernetes 步入雲原生的時代後， kubernetes 把以往的操作系統

原創 2024-04-23 11:47:10

Java中List、Set、Map的區別

結構特點 List 和 Set 是存儲單列數據的集合，Map 是存儲鍵和值這樣的雙列數據的集合；List 中存儲的數據是有順序，並且允許重複；Map 中存儲的數據是沒有順序的，其鍵是不能重複的，它的值是可以有重複的，Set 中存儲的數據

原創 2024-04-22 21:31:29

下載量超 200 萬，最近頻繁登上熱搜的 AI 程序員，大家怎麼看

人狠話不多，會熟練使用 200 多種編程語言，寫得了代碼，做得了測試，7 天 24 小時隨叫隨到…… 硅基程序員通義靈碼首次入職阿里雲，有網友說：終於不穿格子衫了！ 還有網友說：這簡歷，作爲一個 HR 我很難不心動！ 人狠話不多的通義靈碼，

原創 2024-04-22 21:12:06