java入門學習

Table of Contents

• 1 第一個java程序，輸出hello world
• 2 第二個java程序，輸入a與b的值，然後輸出 a+b
• 3 java當中的if語句
• 4 樣例1
• 5 java同樣支持三元運算符
• 6 switch條件語句
• 7 while循環語句
• 8 do – while 循環語句
• 9 java大數a+b
• 10 java數組冒泡排序
• 11jave如何調大字體（2019.9.17）
•  
• 12多維數組的學習(2019.9.17)
• 13package是什麼意思（20190924）
• 14super語句的用法（20190924）
• 15static在java當中（20190924）
• 16關於多態的學習（2019.9.29）
•  
• 17 over在java中的作用（2019.9.29）
• 18 什麼是內部類（2019.9.29）
• 19java中方法的重載和使用（20191008）
• 20java中函數的使用（20191008）
  • 具體樣例
• 21java中的二分查找（遞歸）（20191008）
• 22.java中異常的學習
  • 一, 什麼是java裏的異常
    • 1.1 c語言裏的錯誤
•  
  • • 1.2關於java
  • 二, java裏的異常的分類.
• 23.java中字符串類string的相關操作、
• （2019.11.19）24.如何在java中聲明一個類，並対類變量進行排序
• 25有關容器接口的相關學習資料

1 第一個java程序，輸出hello world

 

package com.itheima.first;
public class HelloWorld {
	public static void main(String[] args) {
		System.out.println("Hello world");
		
	}
}

2 第二個java程序，輸入a與b的值，然後輸出 a+b

 

import java.util.Scanner;
//上面這句話在提交代碼的時候不能省略
public class Main {
	public static void main(String args[])throws Exception{
		Scanner cin = new Scanner(System.in);
		int a =  cin.nextInt(), b= cin.nextInt();
		System.out.println(a+b);
		
	}
}

3 java當中的if語句

如果滿足某種條件就進行某種處理

if(語句塊){
執行語句1;
}
//------------
if(判斷條件） {
    執行語句1;
    ...
}
else {
    執行語句2;
    ...

}

4 樣例1

輸入學生成績，通過if語句判斷學生等級

package demoif;
import java.util.*;
public class Exampleif {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		int score;
		Scanner input = new Scanner(System.in);
		score = input.nextInt();
		if(score >= 90){
			System.out.println("A");
		}
		else{
			if(score >= 80)  
				System.out.println("B");
			else
				System.out.println("c");
			
		}
	}

}

5 java同樣支持三元運算符

（無具體內容）

6 switch條件語句

switch（只能是int或者是char或者是符合條件的值）
{
    case 1:
    執行語句1;
    break;
...

}
//要記得break否則所有內容都執行

注意case存在穿透現象

7 while循環語句

8 do – while 循環語句

9 java大數a+b

package demoif;
import java.math.BigInteger;
import java.util.*;
import java.math.BigDecimal;
import java.util.Scanner;
public class Exampleif {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		BigInteger a, b;
		Scanner input1 = new Scanner(System.in);
		a = input1.nextBigInteger();
		b = input1.nextBigInteger();
		BigInteger c = a.add(b);
		System.out.println(c);
	}

}

10 java數組冒泡排序

與C、C++不同，Java在定義數組時並不爲數組元素分配內存，因此[ ]中無需指定數組元素的個數，即數組長度。而且對於如上定義的一個數組是不能訪問它的任何元素的，我們必須要爲它分配內存空間，這時要用到運算符new，其格式如下：
arrayName=new type[arraySize];
其中，arraySize 爲數組的長度，type 爲數組的類型。如：

1. demoArray=new int[3];

爲一個整型數組分配3個int 型整數所佔據的內存空間。

通常，你可以在定義的同時分配空間，語法爲：
type arrayName[] = new type[arraySize];
例如：

int demoArray[] = new int[3];

package demoif;
import java.math.BigInteger;
import java.util.*;
import java.math.BigDecimal;
import java.util.Scanner;
public class Exampleif {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		int [] a = new int [10];
		Scanner input = new Scanner(System.in);
		for(int i = 0; i < a.length; i++){
			//Scanner input1 = new Scanner(System.in);
			a[i] = input.nextInt();
		}
		//System.out.println(c);
		bsort(a);
		ansprint(a);
	}
	public static void bsort(int [] a) {
		for(int i = 0; i < a.length - 1; i++){
			for(int j = 0; j < a.length - 1 - i; j++){
				if(a[j] > a[j+1]){
					int t;
					t      = a[j];
					a[j]   = a[j+1];
					a[j+1] = t;
				}
				
			}
			
		}
		
	}
	public static void ansprint(int [] a) {
		for(int i = 0; i < a.length; i++){
			System.out.println(a[i]);
		}
	}

}

11jave如何調大字體（2019.9.17）

https://blog.csdn.net/qq_41694906/article/details/81182700

 

12多維數組的學習(2019.9.17)

package cheapet01;
import java.util.Scanner;
public class array {

	/**
	 * @param args
	 */
	
	/*
	 * 有一個n*n的棋盤，每個棋位上都輸入一個數字，求解，棋盤上所有數字的和是多少
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//多維數組的申請和使用
		int n;
		Scanner cin = new Scanner(System.in);
		n = cin.nextInt();
		int [][] arr = new int [n][n];
		for(int i = 0; i < n; i++){
			for(int j = 0; j <n; j++){
				arr[i][j] = cin.nextInt();
			}
		}
		//這是一個n*n大小的棋盤
		int sum = 0;
		for(int i = 0; i < n; i++){
			for(int j = 0; j <n; j++){
				sum += arr[i][j];
			}
		}
		cin.close();
		System.out.println(sum);
		
		
	}

}

 

13package是什麼意思（20190924）

在java項目中package相當於是一個文件夾用於對class類文件（即.java文件進行分類和保存的上級目錄），因此每次在創建java project的時候都要記得下一步創建的package然後在相應的package下創建class文件

14super語句的用法（20190924）

內容學習參考於傳送門

super( )其實就相當於一個指向基類的指針，（要記住Java中沒有指針，但是可以這樣理解）。

• super.XXX( 這裏的XXX指的是父類的成員變量名即父類的屬性，或者對象名）
•  super.XXX( ) ( 這裏的XXX是父類中的其中一個方法名)
• super( ) ( 這種形式指的是：調用父類沒有參數的構造方法（也叫構造函數）注意： 這裏super( ) 只能放在子類的構造方法裏面，並且只能放在構造方法的首句)

super( x,y,z…) （此形式指：調用父類有參數的構造方法，也必須放在子類的構造方法（成員方法不可以）裏面，並且只能放在構造方法的首句。其中x,y,z是指的與父類此有參構造方法中參數數據類型相對應的子類中的參數）

——————————-java文件創建情況————————————

 

 

父類代碼

package cheapt01;

public class Father {

	protected String head = "父類進行輸出了";
	Father(){
		System.out.println(head);
		
	}
	Father(int a){
		System.out.println(a);
	}

}

子類代碼

package cheapt01;

public class Son extends Father{
	private static int a = 1;
	
	public Son(){
		System.out.println(super.head);
		//由於繼承了父類，因此可以直接調用父類中的字符串
		
	}
	public void test(){
		//測試函數
	}
	public static void main(String[] args){
		Son s = new Son();
		
		
	}

}

extends在java中的含義就意味着繼承

可以很清楚的看到main函數中申請了一個名字爲s的Son變量，那麼就會調用父類中的String

15static在java當中（20190924）

參考於博客：【】傳送門】Java中static的含義和用法

static:靜態的，用於修飾成員(成員變量，成員方法);

1.被static所修飾的變量或者方法會儲存在數據共享區;

2.被static修飾後的成員變量只有一份！

3.當成員被static修飾之後，就多了一種訪問方式，除了可以被對象調用之外，還可以直接

被類名調用，(類名.靜態成員);

4.static的特點：

1）隨着類的加載而被加載;

2）優先於對象存在;

3）被所有對象共享;

5.被static修飾的變量成爲靜態變量(類變量)或者實例變量;

6.存放位置

1）類變量隨着類的加載而存在於date內存區;

2）實例變量隨着對象的建立而存在於堆內存;

7.生命週期：

1)類變量週期生命最長，隨着類的消失而消失;

2)實例變量生命週期比類變量短，它是隨着對象的消失而消失;

8.方法注意事項：

1)靜態的方法只能訪問靜態的成員;

2)非靜態得方法即能訪問靜態得成員(成員變量，成員方法)又能訪問非靜態得成員;

3)局部變量不能被static修飾;

4)靜態得方法中是不可以定義this、super關鍵字的，因爲靜態優先於對象存在，所以靜態方法不可以出this;

 

9.什麼時候使用static修成員：

當屬於同一個類的所有對象出現共享數據時,就需要將存儲這個共享數據的成員用static修飾;

 

10.什麼時候使用static修飾方法：

當功能內部沒有訪問到非靜態的成員時（對象特有的數據）那麼該功能可以定義成靜態的;

16關於多態的學習（2019.9.29）

什麼是多態？

多態是指不同類對象在調用同一個方法時所呈現出的多種不同行爲。

多態的作用：通過多態消除了類之間的耦合關係，大大提高了程序的可擴展性和可維護性

注意：一個父類可以有多個子類，但是一個子類只能有一個父類。（區別於接口）

如下典型的向上轉型

Animal a = new Dog();

向下轉型：

Animal a =new Dog();
Dog b = (Dog) a;

(向下轉型是不安全的，所以有這麼一個判斷關鍵詞）

if(an1 instanceof Cat){

}
else{

}

通過instanceof 進行判斷，在向下轉型的過程中判斷與哪一個子類對象是對應的，然後在進行轉型，避免了向下轉型的錯誤，並且提高了程序的可讀性和安全性。

 

 

17 over在java中的作用（2019.9.29）

@Override是僞代碼,表示重寫(當然不寫也可以)，不過寫上有如下好處:  1、可以當註釋用,方便閱讀； 2、編譯器可以給你驗證@Override下面的方法名是否是你父類中所有的，如果沒有則報錯。例如，你如果沒寫@Override，而你下面的方法名又寫錯了，這時你的編譯器是可以編譯通過的，因爲編譯器以爲這個方法是你的子類中自己增加的方法。   舉例：在重寫父類的onCreate時，在方法前面加上@Override 系統可以幫你檢查方法的正確性。 @Override public void onCreate(Bundle savedInstanceState)

18 什麼是內部類（2019.9.29）

在java當中，允許在一個類內部再定義一個類。

成員內部類，定義：在一個類中除了可以定義成員變量、成員方法，還可以再定義一個成員類

內部類可以調用外部類的變量和方法

注意外部類變量在使用的時候無法想直接使用內部類的函數

（在編譯器中直接報錯無法運行）

package day9282;
public class Outer{
    int o = 10;
    public void oMethod(){
    System.out.println("外部類輸出函數");
    
}
    class Innner{
    int i = 20;
    public void iMethod(){
    System.out.println("內部類輸出函數");

}
}

}

package day9282;
public class Demon01{
    public static void main()(String []args){
//主程序口
}
}

19java中方法的重載和使用（20191008）

在c++當中，存在着這麼一種方法，就是對函數的重載，使得程序變得更加的高效。

簡單介紹：它是指我們可以定義一些名稱相同的方法，通過定義不同的輸入參數來區分這些方法，然後再調用時，編譯器就會根據不同的參數樣式，來選擇合適的方法執行。

注意，是定義不同的輸入參數來區分方法（因爲重載的函數，函數名字是相同的）

20java中函數的使用（20191008）

通常我們定義函數會定義在一個公共類當中，而不是直接寫在主類的下方，那麼我們在調用類外函數的時候應該怎麼樣去書寫它呢？

那麼就是先寫類的名字然後加上.（這個點在這裏是引用的意思，相信寫過c++或者是c的朋友不會陌生）然後在加上方法名（通常引用點一寫就會跳出來供你選擇）

具體樣例

package cheapt01;

public class Example05 {
	//java當中方法的重載
	public static int add(int x, int y){
		return x+y;
	}
	public static int add(int x,int y,int z){
		return x+y+z;
	}
	public static double add(double x,double y){
		return x+y;
	}
	
}

 

package cheapt01;

import java.util.Scanner;

public class demo01 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int x, y, z;
		Scanner cin = new Scanner(System.in);
		x = cin.nextInt();
		y = cin.nextInt();
		z = cin.nextInt();
		int tmp1 = Example05.add(x,y,z);
		int tmp2 = Example05.add(x,y);
		System.out.println(tmp1);
		System.out.println(tmp2);
	}

}

21java中的二分查找（遞歸）（20191008）

package cheapt01;

public class Example07 {
//二分查找遞歸方法
	public static int HalfSearch(int a[],int key, int start,int end){
		int mid = (start + end) >> 1;
		
		if(key == a[mid]){
			System.out.println(mid);
			return 0;
		}
		else if (key < a[mid]){
			HalfSearch(a, key, start, mid);
			
		}
		else if(key > a[mid]){
			HalfSearch(a, key, mid, end);
		}
		else{
			System.out.println("error");
			return -1;
		}
		return -1;
	}
}

package cheapt01;

import java.util.Scanner;

public class demo01 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int n;
		System.out.println("請輸入n值");
		Scanner cin = new Scanner(System.in);
		n = cin.nextInt();
		int [] a = new int [n];
		System.out.println("請輸入n個數字");
		
		for(int i = 0; i < n; i++){
			a[i] = cin.nextInt();
		}
		for(int i = 0; i < n - 1; i++){
			for(int j = 0; j < n - i - 1; j++){
				if(a[j] > a[j+1]){
					int tmp = a[j];
					a[j]    = a[j+1];
					a[j+1]  = tmp;
				}
			}
		}
		int key;
		System.out.println("請輸入key值");
		key = cin.nextInt();
		Example07.HalfSearch(a, key, 0, n-1);
	
	}

}

 

22.java中異常的學習

參考於：https://www.cnblogs.com/taiwan/p/7073743.html

一, 什麼是java裏的異常

由於java是c\c++ 發展而來的,  我們可以先看看c語言裏的錯誤.

1.1 c語言裏的錯誤

        我們實現1個程序的過程包括,  代碼編寫, 編譯代碼成爲程序,  執行程序

 

其中大部分常見的語法錯誤都會被編譯代碼這樣部過濾掉.   但是即使通過了編譯. 執行程序這一步可能還是會有錯誤.

 

        原因很多, 例如常見的除數爲0,    內存溢出(數組的index超出界限), 或者內存被其他程序修改等就會出現程序異常的情況.

1.2關於java

java是有c\c++發展而來的，java當中依然存在於類似於c\c++中的異常情況，c++和c中的解決辦法一般是提前進行判斷，或者是異常拋出判斷

例如如下程序（除程序，當分母爲0時會出現異常）

package test01;

import java.util.Scanner;

public class Demo01 {

	public static int div(int a, int b){
		return a/b;
	}
	//除函數，當b == 0 的時候會出現異常
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int a, b;
		Scanner cin = new Scanner(System.in);
		a = cin.nextInt();
		b = cin.nextInt();
		int ans = div(a, b);
		System.out.println(ans);
		
	}

}

出現異常

但是可以見到, java告訴你出錯的類型: 運算錯誤(ArithmeticExcetion), 出錯信息和出錯的類與文件行數輸出, 方便你調試. jvm虛擬機是會對錯誤作出一定的處理的.
所以可以簡單地將java裏的異常理解成java運行時出現的錯誤, 異常機制就是對這種錯誤進行處理的機制.

實際上, 當java程序執行時出現錯誤時, jvm會把執行時出錯的信息(例如出錯原因, 類型, 位置) 收集,然後打包成爲1個對象(object),  程序員可以對這種對象進行處理. 這種對象就是所謂的異常.

 

        可能出現的異常的代碼並不是肯定會出現異常, 取決於執行環境和數據.!

 

二, java裏的異常的分類.

 

見下圖:

 

                       Throwable

                      /                \

              Error             Exception

                 /                   /               \

         xxxxxx             xxxxxx          RuntimeException

                                                          /                   \

xxxxxx             ArithmeticException

 

 

 

上圖的所有對象都是類.

 

Throwable 代表是可拋出的.

Error            代表的是嚴重錯誤,  這種錯誤程序員無法進行處理, 例如操作系統崩潰, jvm出錯, 動態鏈接庫失敗等.  Error並不是異常, 不是本文的重點.

 

Exception    代表的就是異常了.  它下面很多派生類,   其中它的派生類也分兩種, 一種是RuntimeException(運行時異常), 其他的都是非運行時異常

 

RuntimeException    包括除數爲0, 數組下標超界等. 運行時異常的派生類有很多, 其產生頻率較高.  它的派生類可以由程序處理或者拋給(throw) 給jvm處理. 例如上面的例子就是拋給了jvm處理, jvm把程序中斷執行, 並把錯誤信息輸出到終端上.

 

非RuntimeExcption   這種異常屬於Excepion的派生類(上面紅色的xxx), 但是不是RuntimeException的派生類,  這種異常必須由程序員手動處理,否則不通過編譯.

 

ArithmeticExcpetion   算術異常, 它是RuntimeException的派生類, 所以程序員不手動處理也通過編譯, 只不過出錯時會被jvm處理.

 

package test01;

import java.util.Scanner;

public class Demo01 {

	public static int div(int a, int b){
		int i = 0;
		try{
			i = a/b;
			
		}
		catch (Exception e){
			System.out.println("Exception occur!");
			System.out.println(e.getMessage());//輸出原因
		}
	}
	//除函數，當b == 0 的時候會出現異常
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int a, b;
		Scanner cin = new Scanner(System.in);
		a = cin.nextInt();
		b = cin.nextInt();
		int ans = div(a, b);
		System.out.println(ans);
		
	}

}

 

23.java中字符串類string的相關操作、

package Day1022;

import java.util.Random;

public class Demo01 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// string 類的常見操作
		String Str1 = "";   //string的第一種聲明方式 無參數 
		String Str2 = null; //string的第二種聲明方式 無參數，指向空指針
		String Str3 = "abs";//string的第三種聲明方式
		
		char []charArry = new char []{ 'A', 'B', 'C'};
		String Str4 = new String(charArry); //通過已知數組對string進行初始化
		String Str5 = new String(Str3);     //使用已知的string類對新string進行初始化
		
		/*
			下面進行string類常用操作的測試
		*/
		String StrTest = "abuciketdncbcgdketduq";
		/*
		 * 返回指定字符在此字符串中第一次出現的索引
		 */
		Demo01.Pri(StrTest);
		int Test1 = StrTest.indexOf('d');
		System.out.println("(1)String.indexOf find the char d first take place in " + Test1);
		/*
		 *  返回指定字符在字符串中最後一次出現的索引
		 */
		int Test2 = StrTest.lastIndexOf('b');
		System.out.println("(2)String.lastIndexOf: find the char b last take place in " + Test2);
		/*
		 * 返回指定字符在此字符串中第一次出現的索引
		 */
		int Test3 = StrTest.indexOf("ket");
		System.out.println("(3)String.indexOf: find the string {ket} first take place in " + Test3);
		
		/*
		 * 返回指定字符串在此字符串中最後一次出現的索引
		 */
		int Test4 = StrTest.lastIndexOf("ket");
		System.out.println("(4)String.lastIndexOf: find the string {ket} last take place in " + Test4);
	
		/*
		 * 返回字符串中指定位置index上的字符
		 */
		System.out.println("返回字符串中指定位置index上的字符");
		System.out.print("(5)");
		for (int i = 0; i < StrTest.length(); i++) {
			if(i == 0)  System.out.print(i); else System.out.print(" " + i);
		}
		System.out.println();//換行
		System.out.print("(6)");
		for(int i = 0; i < StrTest.length(); i++){
			if(i == 0) System.out.print(StrTest.charAt(i)); else System.out.print(" " + StrTest.charAt(i));
		}
		
		/*
		 * 判斷字符串是否以指定字符結尾
		 */
		//System.out.println(StrTest.endsWith('q'));
		System.out.println();
		System.out.print("(7)StrTest.endsWith: judge whether string {q} is the end character of a string , the answer is " + (Boolean)StrTest.endsWith("q"));
		
	}
	
		public static void Pri(String s){
			System.out.println("test answer : " + s);
		}
	

		
		 

}

test answer : abuciketdncbcgdketduq
(1)String.indexOf find the char d first take place in 8
(2)String.lastIndexOf: find the char b last take place in 11
(3)String.indexOf: find the string {ket} first take place in 5
(4)String.lastIndexOf: find the string {ket} last take place in 15
返回字符串中指定位置index上的字符
(5)0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
(6)a b u c i k e t d n c b c g d k e t d u q
(7)StrTest.endsWith: judge whether string {q} is the end character of a string , the answer is true

package Day1022;

public class Eample03 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str = "java";
		char [] charArry = str.toCharArray();
		System.out.println("make the string to be char[] : ");
		for (int i = 0; i < charArry.length; i++) {
			if(i == 0) {System.out.print(charArry[i]);} else{System.out.print(" " + charArry[i]);}
		}
		
	}

}

 

（2019.11.19）24.如何在java中聲明一個類，並対類變量進行排序

extends與implements的不同

1、在類的聲明中，通過關鍵字extends來創建一個類的子類。

一個類通過關鍵字implements聲明自己使用一個或者多個接口。

extends 是繼承某個類, 繼承之後可以使用父類的方法, 也可以重寫父類的方法;

implements 是實現多個接口, 接口的方法一般爲空的, 必須重寫才能使用 

2、extends是繼承父類，只要那個類不是聲明爲final或者那個類定義爲abstract的就能繼承

Java中不支持多重繼承，但是可以用接口 來實現，這樣就要用到implements，繼承只能繼承一個類，

但implements可以實現多個接口，用逗號分開就行了 比如 ：

class A extends B implements C,D,E

接口實現的注意點：

a.實現一個接口就是要實現該接口的所有的方法(抽象類除外)。 

b.接口中的方法都是抽象的。

c.多個無關的類可以實現同一個接口，一個類可以實現多個無關的接口

這裏我解答的是 PAT (Basic Level) 1004

【題目】輸入n個學生的姓名、學號、成績，找出成績最好的和成績最差的，進行輸出

【解題思路】聲明一個學生類，対學生類進行一下排序

【知識點】

1. 対類進行排序，需要重寫compare
2. 如何聲明一個類數組 student [] arr = new student [n];
3. java中的容器排序算法 Arrays.sort( 容器名字, 容器起始位置，容器結束位置)：
4. 接口的使用
5. split的使用，按照特殊的符號対字符串進行分割，可以再輸入的時候直接使用，十分的方便
   （1）split表達式，其實就是一個正則表達式。*  ^ | 等符號在正則表達式中屬於一種有特殊含義的字符，如果使用此種字符作爲分隔符，必須使用轉義符即\\加以轉義。

   （2）如果使用多個分隔符則需要藉助 | 符號，如二所示，但需要轉義符的仍然要加上分隔符進行處理

   （3）字符串.split(分隔符號);
6. 使用Arrays.sort一定需要加上接口Comparable ，並且程序內重寫的是compareTo而不是compare

import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

	class student implements Comparable <student>{
		
		String name  = null;
		String num   = null;
		int    score = 0;
		public student(String rname, String rnum,int rscore ){
			name = rname;
			num  = rnum;
			score= rscore;
		}
		@Override
		public int compareTo(student a) {
			// TODO Auto-generated method stub
			return a.score - this.score;
		}
		
		
	}
	public class Main {

		/**
		 * @param args
		 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int n; Scanner cin = new Scanner(System.in);
		n = cin.nextInt();
		student [] arr = new student [n+1];
		cin.nextLine();
		for(int i = 0; i < n; i++){
			String tmp = cin.nextLine();
			String []stu = tmp.split(" ");
			int t = Integer.valueOf(stu[2]).intValue();
			arr[i] = new student(stu[0], stu[1], t);
			
		}
		Arrays.sort(arr, 0, n);
		System.out.println(arr[0].name + " " + arr[0].num);
		System.out.print(arr[n-1].name + " " + arr[n-1].num);
	}

}

 

25有關容器接口的相關學習資料

https://blog.csdn.net/qq_30447263/article/details/83034711

 

 

26容器的學習

package Day03;

import java.awt.List;
import java.util.ArrayList;

public class Demo01 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		/*
		 * @author ： scbtxdy
		 * ArrayList 是 List接口的一個實現類， A仍然有List內部封裝了一個長度可變的數組對象 
		 * ArrayList add 增加一個元素 get讀取該位置上的元素 size()返回該集合的大小
		 * 
		 */
		ArrayList list = new ArrayList();
		list.add("first");
		list.add("second");
		list.add("third");
		System.out.println(list);
		System.out.println("集合大小 = "+list.size());
		System.out.println("集合當中第二個元素 = "+ list.get(1));
		list.set(0, "first had be replace");
		System.out.println("對集合第一個位置進行了操作 ： "+list.get(1));
		System.out.println("返回對象o在集合內第一次出現的索引" + list.indexOf("second"));
		list.add("four"); list.add("five"); list.add("six"); list.add("seven");
		/*
		 * 20191203
		 * subList 的坑  https://www.cnblogs.com/latteyan/p/7644527.html
		 * 子序列指向的地方還是原序列的地方
		 * 修改子序列原序列也會受到修改，因爲函數的內部是引用
		 */
		System.out.println("子序列"+list.subList(3,  5));
		
		/*
		 * ArrayLsit 集合查詢元素的速度極快，但在增刪元素時候的效率極低，爲了克服這種侷限，可以使用List接口的另一個實現類LinkedList
		 * 該集合內部飽和兩個Node類型的first和last屬性維護一個雙向循環鏈表，鏈表中的每一個元素都使用引用的方式來記住它的前一個元素和後一個元素，
		 * 從而可以將所有元素彼此鏈接起來。
		 */
	}

}