2018.6.20 Java考試試題總結（Java語言基礎與面向對象編程）最新版

時間 2020-07-09

標籤 2018.6.20 java 考試試題總結語言基礎面向對象編程最新版欄目 Java 简体版

原文原文鏈接

Java考試試題總結

##1、單選題（每題1分 * 50 = 50分） ###1．java程序的執行過程當中用到一套JDK工具，其中javac.exe指（ B ）java

A．java語言解釋器
B．java字節碼編譯器
C．java文檔生成器
D．java類分解器

###2．在Java語言中，不容許使用指針體現出的Java特性是（ D ）程序員

A．可移植
B．解釋執行
C．健壯性
D．安全性

###3． 00101010(&)00010111語句的執行結果是( C )編程

###4．在Java中語句：37.2%10的運算結果爲( A )數組

A．7.2
B．7
C．3
D．0.2

###5．0.6332 的數據類型是（ B ）瀏覽器

A．float
B．double
C．Float
D．Double

###6．System.out.println(「5」 + 2);的輸出結果應該是（ A ）安全

A．52
B．7
C．2
D．5

 System.out.println("5"+2+1);//521

###7．下面的方法，當輸入爲 2 的時候返回值是多少（ D ）多線程

public static int getValue(int i) {
        int result = 0;
        switch (i) {
        case 1:
            result = result + i;
        case 2:    //從這裏進去    result=0+2*2  =4
            result = result + i * 2;
        case 3:     //由於沒有break結束   因此直接進入   result= 4+2*3  =10
            result = result + i * 3;
        }
        return result;
}


A．0
B．2
C．4
D．10

###8．下列語句中，屬於多分支語句的是（ B ）併發

A．if語句
B．switch語句
C．do while語句
D．for語句

###9．下列程序執行的結果是（ C ）。app

public class Ex6 {
    public static void main(String[] args) {
        char ch='8';
        int r=10;
        switch(ch+1) {  //第一次 9     第二次  15+1
            case '7': r=r+3;
            case '8': r=r+5;
            case '9': r=r+6;//9+6=15
                break;
            default: ;
        }
    System.out.print(r);
    }
}


A．14
B．13
C．16
D．10

###10．執行以下程序代碼後，a的值是多少（ C ）編程語言

public class Ex10 {
    public static void main(String[] args) {
       int a=0;
       int c=0;
        do{
        --c;
        a=a-1;
        }while(a>0);
        System.out.println("aa"+a);
    }    
}

A．0       B．1       C．-1      D．死循環

do while的特色:
	當不知足循環條件就退出,這種循環的特色是至少會執行循環一次，先執行循環後判斷

###11．下面程序代碼執行的結果爲：（ B ）

public class Ex11 {
    public static void main(String[] args) {
      for(int i = 0;i<5;i++){
        System.out.println(i++);
        if(i%3==0)
        break;
        }   
    }
}

A．0   1   2
B．0   2
C．0   2   4
D．0   1   3


使用break語句是跳出循環執行循環以後的語句，而continue語句是停止本次循環繼續執行下一次循環。

###12．下列數組聲明中錯誤的是（ D ）

A．int[] a         B．int a[]
C．int[][] a       D．int a[10]

###13．執行完代碼」int[] x=new int[25];」後，如下( A )說明正確的

A．x[24]爲0
B．x[24]未定義
C．x[25]爲0
D．x[0]爲空

###14.應用程序的main方法中有如下語句，則輸出的結果是（ A ）

public class Ex14 {
    public static void main(String[] args) {
       int[]  x= {122,33,55,678,-987};
        int  y= x[0];
        for(int i=1;i<x.length;i++){
            if(x[i]>y)
                y =x[i];
            }
            System.out.println(y);
    }
}

A．678   B．122   C．-987   D．33

##15．方法methodA返回類型是（ A ）

public class ReturnIt{
     return Type methodA(byte x, double y) {
       return (short) x/y * 2;
   }
}

A．int    B．byte    C．long  D．double

###16．下面程序運行的結果是（ A ）

public class X {
    private static int a;
    public static void main(String [] args) {
        modify(a);
        System.out.println(a);
    }

    public static void modify(int a) {
        a++;
    }
}

A．0       B．1       C．程序編譯失敗       D．程序拋出異常

###17．給定以下Java程序的方法結構，則方法體實現語句正確的是（ C ）

public String change(int i){ //方法體 }

A．return 100;
B．return ‘a’;
C．return i+」」;
D．return i;

###18．下列語句正確的是（ A ）

A．形式參數能夠被視爲local variable （局部變量）
B．形式參數可被字段修飾符修飾
C．形式參數爲方法被調用時，真正被傳遞的參數
D．形式參數不能夠是對象

A：形式參數和局部變量同樣，生命週期隨着方法的結束而終結，離不開方法。在Java中形式參數都是值傳遞的，因此能夠視爲一個局部變量。

B：Java中字段修飾符有：public、protected、default、private、final、static。在形式參數中，若是要使用字段修飾符，只能使用final修飾符。其餘任何修飾符都能引發編譯器錯誤。

C：java中方法沒有引用調用，調用的形參都是拷貝的。 
D：形式參數能夠是值或者對象。

###19．在某個類中存在一個方法：void getSort(int x),如下能做爲這個方法的重載聲明的是（ C ）

A．public getSort(float x)   沒有返回類型 必定是構造函數 不能重載
B．int getSort(int y)   參數同樣不是重載
C．double getSort(int x,int y)
D．void get(int x, int y)

重載斷定就是方法名相同傳入的參數不一樣  參數列表不一樣

###20．given the following

public class X {
    public static void main(String [] args) {
       String d="bookkeeper";
	    d.substring(2,9);//這裏須要從新接收字符串  含義是重第二個開始到第九個位置結束 okkeepe
	    d = "u"+d; //仍是用最開始的d字符串
	    System.out.println(d);
    }
}
What is the result （  B ）

A．uookkeewoo
B．ubookkeeper
C．ubookkeepertoo
D．An exception is thrown at runtime

總結：substring(x)是從字符串的的第x個字符截取
     substring(x,y）是從x到y前的位置中止

###21．下面程序運行的結果是（ A ）

public class Test1{
    public static void main(String args[]){
        String a="1234";
        String b="1234";
        String c = new String("1234");
        System.out.println(a==b);//True  比較的是地址
        System.out.println(a==c);//false 比較的是地址
        System.out.println(a.equals(c));//true  比較的是內容
	}
}

A．true false true
B．true true  false
C．true false false
D．true true  true

####22．給定以下Java代碼，編譯運行後，輸出的結果將是（ B ）

public class Test {
    public static void main(String args[]) {
        String s1 = new String("Test");
        String s2 = new String("Test");
        if (s1 == s2)
            System.out.println("Same");//比較的是地址   new出來是開闢新的空間
        if (s1.equals(s2))
            System.out.println("Equals");//比較的是內容
    }
}

A．Same
B．Equals
C．SameEquals
D．什麼都不輸出

###23．下面的代碼執行結果是（ A ）

public class TT{
    public static void main(String[]args){
        String a = "A";
        StringBuffer b = new StringBuffer("B");
        StringBuffer c = new StringBuffer("C");//初始化出的StringBuffer對象的內容就是字符串」C」
        change(a,b,c);
            System.out.println(a+","+b+","+c);//A,B1,C
}
static void change(String s,StringBuffer s1,StringBuffer s2){
    s=s+"1";
    s1.append("1");
        System.out.println("1"+s2);// C
    s2=new StringBuffer("C1");C  //初始化出的StringBuffer對象的內容就是字符串」C1」
        System.out.println("2"+s2);// C1
    }
}

A．A,B1,C
B．A1,B1,C1
C．A,B,C
D. A1,B,C

注意：String類是final變量不能夠修改，stringbuffer 是new出來的，生成的對象根據括號裏面的內容來生成

###24．下列說法正確的有（ C ）

A．class中的constructor不可省略
B．constructor必須與class同名，但方法不能與class同名
C．constructor在一個對象被new時執行
D．一個class只能定義一個constructor

方法能夠和類名同名的，和構造方法惟一的區別就是，構造方法沒有返回值。

###25．關於對象的刪除，下列說法正確的是（ B ）

A．必須由程序員完成對象的清除
B．Java把沒有引用的對象做爲垃圾收集起來並釋放
C．只有當程序中調用System.gc()方法時才能進行垃圾收集
D．Java中的對象都很小，通常不進行刪除操做

解釋：在Java中定義對象時每每經過new運算符爲其分配內存空間，因而當再也不但願使用這個對象時須要釋放掉它所佔用的內存。在Java中，釋放內存的工做是由系統自動隱含的進行，編程人員無須關心。

###26．下列描述中，錯誤的是（ A ）

A．Java要求編程者管理內存
B．Java的安全性體如今多個層次上
C．Applet要求在支持Java的瀏覽器上運行
D．Java有多線程機制

在編譯層、解釋層、平臺層分別做不一樣的安全檢查
Applet自己不能運行，但可以嵌入到Web瀏覽器中運行
多線程是Java程序的併發機制，它能同步共享數、處理不一樣的事件

###27．在以下所示的類Test中，共有（ C ）個構造方法

public class Test{
private int x;
public Test(){  //1
	x = 35;
}

public void Test(double f) {
	this.x = (int)f;
}

public Test(double f){  //2
	this.x = (int)f;
}

public Test(String s) { }  //3
}

A．1
B．2
C．3
D．4

構造方法是與clss同名可是無返回值參數能夠不一樣

###28．設 A爲已定義的類名，下列聲明A類的對象a的語句中正確的是（ A ）

A．public  A  a=new  A( );
B．public  A  a=A( );
C．A  a=new  class( );
D．a  A

###29．關於類的靜態成員的不正確描述是（）

A．靜態成員不屬於對象，是類的共享成員
B．靜態數據成員初始化的時機要優先於實例成員
C．靜態成員函數不擁有this指針，須要經過類參數訪問對象成員
D．只有靜態成員函數能夠操做靜態數據成員

###30．下列說法正確的是（ C ）

A．Java中包的主要做用是實現跨平臺功能
B．package語句只能放在import語句後面
C．包(package)由一組類(class)和界面(interface)組成
D．能夠用#include關鍵詞來標明來自其餘包中的類

###31．關於繼承的說法正確的是（ B ）

A．子類將繼承父類全部的屬性和方法
B．子類將繼承父類的非私有屬性和方法
C．子類只繼承父類public方法和屬性
D．子類只繼承父類的方法，而不繼承屬性

###32．下列修飾符中與訪問控制無關的是（ D ）

A．private
B．public
C．protected
D．final

###33．關於被私有訪問控制符private修飾的成員變量，如下說法正確的是（）

A．能夠被三種類所引用：該類自身、與它在同一個包中的其餘類、在其餘包中的該類的子類
B．能夠被兩種類訪問和引用：該類自己、該類的全部子類
C．只能被該類自身所訪問和修改
D．只能被同一個包中的類訪問

###34．關於對象成員佔用內存的說法哪一個正確（ B ）

A．同一個類的對象共用同一段內存
B．同一個類的對象使用不一樣的內存段，但靜態成員共享相同的內存空間
C．對象的方法不佔用內存
D．以上都不對

###35．下列哪一個類的聲明是正確的（ D ）

A．abstract final class HI{}
B．abstract private move(){}
C．protected private number;
D．public abstract class Car{}

類聲明的格式爲： [修飾符]class類名[extends父類名][implements類實現的接口列表]{...} 修飾符指明類的訪問控制符和類型說明符。修飾符包括：public、默認(也稱friendly)、 abstract、final。public和默認(也稱friendly)爲訪問控制符，abstract和final是類型說明符。訪問控制符能夠和類型說明符搭配使用.

####36．如下程序的輸出結果爲（ D ）

class Base {
    public Base(String s) {
        System.out.println("B");
    }
}


class Derived extends Base {
    public Derived(String s) {
        System.out.println("D");
    }
}

public class Test{
    public static void main(String[] args) {
        new Derived("C");
    }
}

A．BD
B．DB
C．C
D．編譯錯誤

###37．在使用super 和this關鍵字時，如下描述正確的是（ A ）

A．在子類構造方法中使用super（）顯示調用父類的構造方法，super（）必須寫在子類構造方法的第一行，不然編譯不經過
B．super（）和this（）不必定要放在構造方法內第一行
C．this（）和super（）能夠同時出如今一個構造函數中
D．this（）和super（）能夠在static環境中使用，包括static方法和static語句塊

解釋：
	super()和this()相似,區別是，super從子類中調用父類的構造方法，this()在同一類內調用其它方法。
	3）super()和this()均需放在構造方法內第一行。
	4）儘管能夠用this調用一個構造器，但卻不能調用兩個。
	5）this和super不能同時出如今一個構造函數裏面，由於this必然會調用其它的構造函數，其它的構造函數必然也會有super語句的存在，因此在同一個構造函數裏面有相同的語句，就失去了語句的意義，編譯器也不會經過。
	6）this()和super()都指的是對象，因此，均不能夠在static環境中使用。包括：static變量,static方法，static語句塊。
	7）從本質上講，this是一個指向本對象的指針, 然而super是一個Java關鍵字。

###38．當編譯並運行如下程序列會出現什麼結果（ A ）

class A{
public int getNumber(int a){
return a+1;
   }
}

class B extends A{
   public int getNumber(int a, char c){
      return a+2;
}
public static void main(String[] args){
	B b=new B();
	System.out.println(b.getNumber(0));
   }
}

A．編譯錯誤
B．運行錯誤
C．1
D．2

###39．閱讀下列程序，選擇哪個是正確的輸出結果（）沒有圖片

A．static A I’m A class static B I’m B class
B．I’m A class I’m B class static A static B
C．static A static B I’m A class I’m B class
D．I’m A class static A I’m B class static B

註釋：靜態成員是累的共享成員
	 靜態變量要在定義時就初始化
	 調用靜態方法時經過類或對象激活

###40．以下題：在子類Child2的方法f()中不能夠操做的變量是（ A ）

package a;
class Parent{
private int i=20;
protected int j=30;
public int k=40;
int h=50;
}

class Child1 extends Parent {    }

class Child2 extends Child1{

void f(){   }

}

A．i            B．j          C．k          D．h

###41．下列程序的運行結果是（）。

class Parent{
	int i=20;
	int j=30;
	void f(){
	System.out.print(」 「+i);
   }
}

class Child extends Parent {
	int i=30;
	int k=40;
	void f(){
	System.out.print(」 「+i);
}
	void g(){
		System.out.print(」 「+k);
}

public static void main(String args[]){
Parent x=new Child();
System.out.print(x.i);
	x.f();
Child x1=(Child)x;
System.out.print(」 「+x1.i);
x1.f();
   }
}

A．30 30 30 30       B．20 20 20 20     C．20 30 30 30     D．都不對

###42．在JAVA 中（ C ）。

A．一個子類能夠有多個父類，一個父類也能夠有多個子類
B．一個子類能夠有多個父類，但一個父類只能夠有一個子類
C．一個子類只能夠有一個父類，但一個父類能夠有多個子類
D．上述說法都不對

###43．下列哪種敘述是正確的（ D ）

A． abstract修飾符可修飾字段、方法和類
B． 抽象方法的body部分必須用一對大括號{ }包住
C． 聲明抽象方法，大括號無關緊要
D． 聲明抽象方法不可寫出大括號

###44．設int a=-2，則表達式a>>3的值爲（ D ）。

A．8
B．0
C．3
D．-1

1000 0010    右移以後 1000  0001

###45．看下面的程序,請給出結果：（ B ）

public class TestObj{
    public static void main(String[] args){
        Object o=new Object(){
            public boolean equals(Object obj){
                return true;
    }
};
    System.out.println(o.equals("Fred"));
    }
}

A．運行時拋出異常
B．true
C．Fred
D．第三行編譯錯誤

###46．下面程序問題（ C ）

interface C {
   name = 「」;
   void f();
   abstract void g();
   void h(){};
}

A．第2行編譯錯誤
B．第4行編譯錯誤
C．第5行編譯錯誤
D．沒有錯誤,正確

###47．如下對抽象類的描述正確的是（ D ）

A.抽象類沒有構造方法
B.抽象類必須提供抽象方法
C.抽象類能夠經過new關鍵字直接實例化
D.有抽象方法的類必定是抽象類

###48．如下描述錯誤的有（ C ）

A.abstract 能夠修飾類、接口、方法
B.abstract修飾的類主要用於被繼承
C.abstract 能夠修飾變量
D.abstract修飾的類，其子類也能夠是abstract修飾的
E.final能夠用來修飾類、方法、變量

###49．關於String，StringBuilder以及StringBuffer，描述錯誤的是（ B ）

A.對String對象的任何改變都不影響到原對象，相關的任何change操做都會生成新的對象
B.StringBuilder是線程安全
C.StringBuffer是線程安全
D.能夠修改StringBuilder和StringBuffer的內容

String 
final 修飾，不可變

StringBuilder  非線程安全、不使用多線程的狀況下，效率高

StringBuffer 
線程安全

###50．在類的定義中能夠有兩個同名函數，這種現象稱爲函數（ C ）。

A.封裝
B.重寫
C.重載
D.繼承

##2、多選題（每題2分 * 10 = 20分） ###1．關於final的說法正確的是（ C D）

A．final通常修飾靜態變量，靜態變量不會發生變化
B．final不能修飾抽象類，抽象類是用來繼承的
C．final修飾的方法，不能被重寫，可是能夠重載
D．final修飾類，類不能被繼承， String就是final類

###2．下列標識符不合法的有（ ACD ）

A．new    B．$Usdollars    C．1234    D．car．taxi

###3．下面錯誤的初始化語句是（ CD ）

A．char str[]=」hello」;
B．char str[100]=」hello」;
C．char str[]={‘h’,’e’,’l’,’l’,’o’};
D．char str[]={‘hello’};

###4．在Java中，下面關於包的陳述中正確的是（ A D ）

A．包的聲明必須是源文件的第一句代碼。
B．包的聲明必須緊跟在import語句的後面。
C．只有公共類才能放在包中。
D．能夠將多個源文件中的類放在同一個包中。

###5．關於數組的描述正確的是（ ACD ）

A． 數組有一個屬性是length
B． 數組有一個方法是length()
C． 數組是固定長度，相同類型，連續的物理存儲空間
D． 數組的聲明能夠是基本數據類型，也能夠是對象類型數組，可是數組自己是引用類型

###6．對於二分搜索法，下面描述正確的是（A C）

A．可用於數組
B．可用於單鏈表
C．只能在已排序的數據上進行
D．最壞狀況下時間複雜度是O（N*LogN）  

二分查找須要在已排序的數組上進行，須要可以經過下標直接索引到值，所以沒法在鏈表上進行
二分查找首先要求數據是有序的,同時要求能隨機訪問數據元素, 有序數組能夠, 鏈表不行,
二分查找由於每次都是從中間點開始查找，因此最壞狀況是目標元素存在於最邊緣的狀況。最壞爲O（LogN）

###7．下列關於類的繼承的描述，正確的有？（B ）

A．一個類能夠直接繼承多個父類
B．一個類能夠具備多個子類
C．子類會自動擁有父類定義的有效訪問權限的方法以及成員變量
D．一個類繼承另外一個類必須重寫父類的方法

###8．下列描述錯誤的是？（B D）

A．類只能繼承一個父類，可是能夠實現多個接口
B．抽象類自身能夠定義成員而接口不能夠
C．抽象類和接口都不能被實例化
D．一個類能夠有多個基類和多個基接口

Java不支持多繼承，只能有一個基類
接口中定義的成員變量默認爲public static final，只可以有靜態的不能被修改的數據成員；並且，必須給你賦初值，其全部成員方法都是public、abstract的，並且只能被這兩個關鍵字修飾。

###9．數據的存儲結構包括？（ A B）

A．順序存儲
B．鏈式存儲
C．圖存儲
D．二叉存儲

###10．關於下面的代碼說法正確的是（ A C）

final class D{
final int no=1;
final void f(){
final String s=」」;
s = 「some thing」;
    }
}

A．該類不可被繼承
B．第2行可不對no賦值
C．f方法不可被重寫
D．沒有編譯錯誤

##3、填空題（每題2分 * 5 = 10分） ###一、若是一個 Java 源程序文件中定義了4個類，則使用編譯命令 javac 編譯該源程序文件，將生成 4 個擴展名爲class 的字節碼文件。

###二、設 x = 2 則表達式 (x++)*3 的值是 6 。

###三、Java 語言的各類數據類型之間提供了兩種轉換：自動轉換、強制轉換。

###四、Java 設計有 gc 關鍵字，這不只防止了內存地址計算錯誤的問題，也省去了編程時對內存進行分配的煩惱。

###五、咱們在Java 程序中把關鍵字 super 加到方法名稱的面前，來實現子類調用父類的方法。

##4、簡答題（每題5分 * 4 = 20分） ###一、抽象類（abstract class）和接口（interface）有什麼異同？

抽象類：包含抽象方法的類就是抽象類 
接口：指抽象方法的集合，方法不包含方法體

相同點：
    都不能被實例化
    接口的實現類或者抽象類的子類都必須實現了接口或抽象類中的方法後才能夠被實例化

不一樣點:
	接口只有定義，方法不能在接口中實現，實現接口的類要實現接口中全部的方法；抽象類能夠有定義與實現，方法能夠在抽象類中實現
接口要實現，抽象類要繼承，一個類能夠實現多個接口，但只能繼承一個抽象類 接口強調設計理念爲「has -a」的關係，抽象類強調「is -a」關係
	接口中定義變量默認爲public static final,且要賦初值，方法必須是public,static，且只能是這兩個；抽象類中能夠有本身的數據成員變量，也能夠有非抽象的成員方法，並且成員變量默認爲default。這些成員變量能夠在子類中被從新定義，也能夠從新賦值，抽象方法（有abstract修飾）不能用peivate,static,synchronized,native等訪問修飾符修飾，同時方法以分號結尾，而且不帶花括號
接口被運用於比較經常使用的功能，便於往後的維護或者添加刪除方法；而抽象類更傾向於充當公共類的角色，不適用於對裏面的代碼進行修改

　　接口是一種特殊形式的抽象類，使用接口徹底有可能實現與抽象類相同的操做。當子類和父類之間存在有邏輯上的層次結構時，推薦使用抽象類；當用於不一樣類之間，定義不一樣類之間的通訊規則，但願支持差異較大的兩個或者更多對象之間的特定交互行爲時，應該使用接口。 
此外，接口能夠繼承接口，抽象類能夠實現接口，抽象類也能夠繼承具體類。抽象類也能夠有靜態的main方法。

###二、什麼是Java虛擬機？爲何Java被稱做是「平臺無關的編程語言」？

Java虛擬機是執行字節碼文件（.class）的虛擬機進程。
java源程序（.java）被編譯器編譯成字節碼文件（.class）。而後字節碼文件，將由java虛擬機，解釋成機器碼（不一樣平臺的機器碼不一樣）。利用機器碼操做硬件和操做系統

由於不一樣的平臺裝有不一樣的JVM，它們可以將相同的.class文件，解釋成不一樣平臺所須要的機器碼。正是由於有JVM的存在，java被稱爲平臺無關的編程語言

###三、說明overload和override的區別。

override（重寫，覆蓋） 
	一、方法名、參數、返回值相同。 
	二、子類方法不能縮小父類方法的訪問權限。 
	三、子類方法不能拋出比父類方法更多的異常(但子類方法能夠不拋出異常)。 
	四、存在於父類和子類之間。 
	五、方法被定義爲final不能被重寫。 

overload（重載，過載） 
	一、參數類型、個數、順序至少有一個不相同。   
	二、不能重載只有返回值不一樣的方法名。 
	三、存在於父類和子類、同類中。 

方法的重寫(Overriding)和重載(Overloading)是Java多態性的不一樣表現。 
重寫(Overriding)是父類與子類之間多態性的一種表現，而重載(Overloading)是一個類中多態性的一種表現。

###四、&和&&的區別？

&和&&都是邏輯運算符號，&&又叫短路運算符
&是位運算，返回結果是int型
&&是邏輯運算，返回結果是bool型

##5、編程題（每題10分 * 2 = 20分） ###一、求100以內的素數（能被1和自己整除）。

public class test {
 public static void main(String[] args) {
  int i,n,k=0;
     for (n = 3; n<=100; n++) {     //3~100的全部數
         i=2;
         while (i<n) {
             if (n%i==0)  break;  //若能整除說明n不是素數，跳出當前循環
             i++;    
      if (i==n) {     //若是i==n則說明n不能被2~n-1整除，是素數
             k++;             //統計輸出數的個數
             System.out.print(i+ "\t ");
             if (k %6==0)    //每輸出5個則換行
              System.out.println();
         }
     }
 }
}

###二、請使用Java編寫程序對數組進行冒泡排序。

public class X{
    public static void main(String[] args){
        int[] arr = {34,2,6,4,23};
        for(int i =0;i<arr.length;i++){
            for(int j = 0;j<i;j++){
                if(arr[i]>arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        for(int i = 0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}