當前位置：首頁 > news >正文

山東臨沂網(wǎng)站設計公司焦作整站優(yōu)化

news 2025/7/11 11:33:39

山東臨沂網(wǎng)站設計公司,焦作整站優(yōu)化,網(wǎng)站聊天系統(tǒng)怎么做,鄭州漢獅做網(wǎng)站費用文章目錄 1、常用API 1.1、Math1.2、System1.3、Object1.4、Arrays1.5、基本類型包裝類 1.5.1、基本類型包裝類概述1.5.2、Integer1.5.3、int和String相互轉換1.5.4、自動裝箱和拆箱 1.6、日期類 1.6.1、Date類1.6.2、SimpleDateFormat類 1.6.2.1、格式化（從Date到…

文章目錄

1、常用API
- 1.1、Math
- 1.2、System
- 1.3、Object
- 1.4、Arrays
- 1.5、基本類型包裝類
- - 1.5.1、基本類型包裝類概述
  - 1.5.2、Integer
  - 1.5.3、int和String相互轉換
  - 1.5.4、自動裝箱和拆箱
- 1.6、日期類
- - 1.6.1、Date類
  - 1.6.2、SimpleDateFormat類
  - - 1.6.2.1、格式化（從Date到String）
    - 1.6.2.2、解析（從String到Date）
  - 1.6.3、Calendar類
- 1.7、String
- 1.8、StringBuilder
- 1.9、Scaner
- 1.10、Random
2、異常
- 2.1、異常概述
- 2.2、JVM的默認處理方案
- 2.3、異常處理
- 2.4、異常處理之try…catch…
- 2.5、Throwable的成員方法
- 2.6、編譯時異常和運行時異常的區(qū)別
- 2.7、異常處理之throws
- 2.8、自定義異常
- 2.9、throws和throw的區(qū)別
3、集合進階
- 3.1、Collection
- 3.2、List
- - 3.2.1、List
  - 3.2.2、List并發(fā)修改異常
  - 3.2.3、ListIterator
  - 3.2.4、增加for循環(huán)
  - 3.2.5、數(shù)據(jù)結構
  - - 3.2.5.1、棧
    - 3.2.5.2、列
    - 3.2.5.3、數(shù)組
    - 3.2.5.4、鏈表
  - 3.2.6、List集合子類特點
  - 3.2.7、LinkedList集合的特有功能
- 3.3、Set
- - 3.3.1、Set集合概述和特點
  - 3.3.2、哈希值
  - 3.3.3、HashSet集合添加一個元素的過程
  - 3.3.4、哈希表
  - 3.3.5、LinkedHashSet
  - 3.3.6、TreeSet
  - 3.3.7、自然排序Comparable的使用
  - 3.3.8、比較器排序Comparator的使用
- 3.4、泛型
- - 3.4.1、泛型概述
  - 3.4.2、泛型類
  - 3.4.3、泛型方法
  - 3.4.4、泛型接口
  - 3.4.5、類型通配符
  - 3.4.6、可變參數(shù)
  - 3.4.7、可變參數(shù)的使用
- 3.5、Map
- - 3.5.1、Map集合概述
  - 3.5.2、Map集合的基本功能
  - 3.5.3、Map集合的獲取功能
  - 3.5.4、Map集合的遍歷
  - 3.5.5、HashMap的案例
  - 3.5.6、ArrayList中嵌套HashMap
  - 3.5.7、HashMap中嵌套ArrayList
  - 3.5.8、統(tǒng)計字符串中每個字符出現(xiàn)的次數(shù)
- 3.6、Collections
- - 3.6.1、Collections的概述
  - 3.6.2、對ArrayList排序

1、常用API

1.1、Math

方法名

說明

public static int abs(int a)

返回參數(shù)的絕對值

public static double ceil(double a)

返回大于或等于參數(shù)的最小double的值，等于一個整數(shù)

public static floor(double a)

返回小于或等于參數(shù)的最大double值，等于一個整數(shù)

public static int round(float a)

按四舍五入返回最接近參數(shù)的int

public static int max(int a,int b)

返回兩個int值中的較大值

public static int min(int a,int b)

返回兩個int值中的較小值

public static double pow(double a,double b)

返回a的b次冪的值

public static double random()

返回double的正值[0.0,1.0)

示例：

public class MathDemo {public static void main(String[] args) {
//        public static int abs(int a)	返回參數(shù)的絕對值System.out.println(Math.abs(88));System.out.println(Math.abs(-88));System.out.println("*************");
//        public static double ceil(double a)	返回大于或等于參數(shù)的最小double的值，等于一個整數(shù)System.out.println(Math.ceil(9.4));//輸出10.0System.out.println(Math.ceil(9.5));//輸出10.0System.out.println("*************");
//        public static floor(double a)	返回小于或等于參數(shù)的最大double值，等于一個整數(shù)System.out.println(Math.floor(9.4));//輸出9.0System.out.println(Math.floor(9.5));//輸出9.0System.out.println("*************");
//        public static int round(float a)	按四舍五入返回最接近參數(shù)的intSystem.out.println(Math.round(9.4F));//輸出9System.out.println(Math.round(9.5F));//輸出10System.out.println("*************");
//        public static int max(int a,int b)	返回兩個int值中的較大值System.out.println(Math.max(2,8));System.out.println("*************");
//        public static int min(int a,int b)	返回兩個int值中的較小值System.out.println(Math.min(2,8));System.out.println("*************");
//        public static double pow(double a,double b)	返回a的b次冪的值System.out.println(Math.pow(2,3));//輸出8.0System.out.println("*************");
//        public static double random()	返回double的正值[0.0,1.0)System.out.println(Math.random());//[0.0,1.0)System.out.println((int)(Math.random()*100));//[1,99)之間的隨機int數(shù)System.out.println((int)(Math.random()*100)+1);//[1,100)之間的隨機int數(shù)System.out.println((int)(Math.random()*91)+10);//[10,100)之間的隨機int數(shù)}
}

1.2、System

System包含幾個有用的類字段和方法，它不能被實例化。

System類的常用方法：

方法名

說明

public static void exit(int status)

終止當前運行的Java虛擬機，非零表示異常終止。

public static long currentTimeMillis()

返回當前時間（以毫秒為單位）

1.3、Object

方法名

說明

toString()

建議所有子類覆蓋此方法。

public boolean equals?(Object obj)

比較對象是否相等。默認比較地址，重寫可以比較內(nèi)容。

1.4、Arrays

Arrays類包含用于操作數(shù)組的各種方法：

方法名

說明

public static String toString?(int[] a)

返回指定數(shù)組的內(nèi)容的字符串表示形式

public static void sort?(int[] a)

按照數(shù)字順序排序指定的數(shù)組

工具類的設計思想：

構造方法用private修飾，主要是不讓外部創(chuàng)建對象。
成員用public static修飾，主要是讓外部可以用類名調(diào)用。

1.5、基本類型包裝類

1.5.1、基本類型包裝類概述

將基本類型封裝成對象的好處在于可以在對象中定義更多的功能方法操作數(shù)據(jù)。
常用的操作之一：用于將基本數(shù)據(jù)類型與字符串之間的轉換。

基本數(shù)據(jù)類型

包裝類

byte

Byte

short

Short

int

Integer

long

Long

float

Float

doube

Double

char

Character

boolean

Boolean

1.5.2、Integer

包裝一個對象中的原始類型int的值。

方法名

說明

public Integer(int value)

根據(jù)int值創(chuàng)建Integer對象（已過時）

public Integer(String s)

根據(jù)String值創(chuàng)建Integer對象（已過時）

public static Integer valueOf(int i)

返回表示指定的int值的Integer實例

public static Integer valueOf(String s)

返回一個保存指定值的Integer對象String

1.5.3、int和String相互轉換

int轉String

		/*int轉String*/int number=100;//方式一：String s=""+number;//方式二：String s1=String.valueOf(number);

String轉int

		/*String轉int*/String s="100";//方式一：String轉Integer轉intInteger i=Integer.valueOf(s);int x=i.intValue();//方式二：int y=Integer.parseInt(s);

1.5.4、自動裝箱和拆箱

裝箱：把基本數(shù)據(jù)類型轉換為對應的包裝類類型。

//裝箱
Integer i=Integer.valueOf(100);
Integer j=100;//自動裝箱，JDK5以后簡化成了此種寫法。

拆箱：把包裝類類型轉換為對應的基本數(shù)據(jù)類型。

//拆箱
Integer i=100;//拆箱
ii=ii.intValue()+1;//ii.intValue()是拆箱
ii+=1;// 自動拆箱

注意： 使用包裝類類型時，若操作，最好先判斷是否為null
只要是對象，使用前必須進行不為null的判斷。

1.6、日期類

1.6.1、Date類

Date代表了一個特定的時間，精確到毫秒

方法名

說明

public Date()

分配一個Date對象，并初始化，以代表它被分配到的時間，精確到毫秒

public Date (long date)

分配一個Date對象，并將其初始化為表示從標準基準時間起指定的毫秒數(shù)

public long getTime()

獲取的是日期對象從1970年1月1日00:00:00到現(xiàn)在的毫秒值

public void setTime(long time)

設置時間，給的是毫秒值

1.6.2、SimpleDateFormat類

用于日期格式化和解析。

方法名

說明

pubblic SimpleDateFormat()

構造一個SimpleDateFormat，使用默認模式和日期格式

public SimpleDateFormat(String pattern)

構造一個SimpleDateFormat模式使用給定的模式和默認的日期格式

1.6.2.1、格式化（從Date到String）

public final format(Date date)：將日期格式化成日期/時間字符串
默認格式

import java.util.Date;
import java.text.SimpleDateFormat;
public class SimpleDateFormatDemo {public static void main(String[] args) {Date d=new Date();SimpleDateFormat sdf=new SimpleDateFormat();String s=sdf.format(d);System.out.println(s);}
}

指定格式

		Date d=new Date();SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");String t=sdf.format(d);System.out.println(t);

1.6.2.2、解析（從String到Date）

public Date parse(String source)：從給定字符串的開始解析文本生成日期

import java.text.ParseException;
import java.util.Date;
import java.text.SimpleDateFormat;
public class SimpleDateFormatDemo {public static void main(String[] args) throws ParseException {String t="2022-02-28 12:00:01";SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date d=sdf.parse(t);System.out.println(d);}
}

1.6.3、Calendar類

Calendar提供了一個類方法getInstance用于獲取Calendar對象，其日歷字段已使用當前日期和時間初始化：
Calendar rightNow=Calendar.getInstance();

import java.util.Calendar;
public class CalendarDemo {
public static void main(String[] args) {
Calendar c=Calendar.getInstance();
int year=c.get(Calendar.YEAR);
int month=c.get(Calendar.MONTH)+1;
int date=c.get(Calendar.DATE);
System.out.println(year+“年”+month+“月”+date+“日”);
}
}

Calendar常用方法：

方法名

說明

public int get(int field)

返回給定日歷字段的值

public abstract void add(int field,int amount)

根據(jù)日歷的規(guī)則，將指定的時間量添加或減去給定的日歷字段

public final void set(int year,int month,int date)

設置當前日歷的年月日

import java.util.Calendar;
public class CalendarDemo {public static void main(String[] args) {Calendar c=Calendar.getInstance();//public abstract void add(int field,int amount)c.add(Calendar.YEAR,-2);//兩年前int year=c.get(Calendar.YEAR);int month=c.get(Calendar.MONTH)+1;int date=c.get(Calendar.DATE);System.out.println(year+"年"+month+"月"+date+"日");// public final void set(int year,int month,int date)c.set(2000,0,1);//將日歷設置為2000-1-1year=c.get(Calendar.YEAR);month=c.get(Calendar.MONTH)+1;//月份從0開始date=c.get(Calendar.DATE);System.out.println(year+"年"+month+"月"+date+"日");}
}

二月天案例：

import java.util.Scanner;
import java.util.Calendar;
public class CalendarDemo {public static void main(String[] args) {Scanner sc=new Scanner(System.in);System.out.println("請輸入年份：");int year=sc.nextInt();Calendar c=Calendar.getInstance();//將日歷設置為3月1日，再減一天就是2月的最后一天c.set(year,2,1);c.add(Calendar.DATE,-1);int date=c.get(Calendar.DATE);System.out.println(year+"年二月有"+date);}
}

1.7、String

1.8、StringBuilder

1.9、Scaner

1.10、Random

2、異常

2.1、異常概述

異常：就是程序出現(xiàn)了不正常的情況

#mermaid-svg-4t2aA5Fz629v7TEb {font-family:“trebuchet ms”,verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-4t2aA5Fz629v7TEb .error-icon{fill:#552222;}#mermaid-svg-4t2aA5Fz629v7TEb .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-4t2aA5Fz629v7TEb .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-4t2aA5Fz629v7TEb .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-4t2aA5Fz629v7TEb .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-4t2aA5Fz629v7TEb .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-4t2aA5Fz629v7TEb .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-4t2aA5Fz629v7TEb .marker{fill:#333333;stroke:#333333;}#mermaid-svg-4t2aA5Fz629v7TEb .marker.cross{stroke:#333333;}#mermaid-svg-4t2aA5Fz629v7TEb svg{font-family:“trebuchet ms”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-4t2aA5Fz629v7TEb .label{font-family:“trebuchet ms”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-4t2aA5Fz629v7TEb .cluster-label text{fill:#333;}#mermaid-svg-4t2aA5Fz629v7TEb .cluster-label span{color:#333;}#mermaid-svg-4t2aA5Fz629v7TEb .label text,#mermaid-svg-4t2aA5Fz629v7TEb span{fill:#333;color:#333;}#mermaid-svg-4t2aA5Fz629v7TEb .node rect,#mermaid-svg-4t2aA5Fz629v7TEb .node circle,#mermaid-svg-4t2aA5Fz629v7TEb .node ellipse,#mermaid-svg-4t2aA5Fz629v7TEb .node polygon,#mermaid-svg-4t2aA5Fz629v7TEb .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-4t2aA5Fz629v7TEb .node .label{text-align:center;}#mermaid-svg-4t2aA5Fz629v7TEb .node.clickable{cursor:pointer;}#mermaid-svg-4t2aA5Fz629v7TEb .arrowheadPath{fill:#333333;}#mermaid-svg-4t2aA5Fz629v7TEb .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-4t2aA5Fz629v7TEb .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-4t2aA5Fz629v7TEb .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-4t2aA5Fz629v7TEb .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-4t2aA5Fz629v7TEb .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-4t2aA5Fz629v7TEb .cluster text{fill:#333;}#mermaid-svg-4t2aA5Fz629v7TEb .cluster span{color:#333;}#mermaid-svg-4t2aA5Fz629v7TEb div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:“trebuchet ms”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-4t2aA5Fz629v7TEb :root{–mermaid-font-family:“trebuchet ms”,verdana,arial,sans-serif;}

Throwable

Error

Exception

RuntimeException

非RuntimeException

Error：嚴重問題，不需要處理
Exception：稱為異常類，它表示程序本身可以處理的問題。
RuntimeException：在編譯期是不檢查的，出現(xiàn)問題后，需要我們回來修改代碼。
非RuntimeException：編譯期就必須處理，否則程序不能通過編譯。

2.2、JVM的默認處理方案

如果程序出現(xiàn) 問題，我們沒有做任何處理，最終JVM會做默認的處理。

把異常的名稱，異常原因及異常出現(xiàn)的位置等信息輸出在了控制臺。
程序停止執(zhí)行。

2.3、異常處理

如果程序出現(xiàn)了問題，我們需要自己來處理，有兩種方案：

try...catch...
throws

格式：

try{可能出現(xiàn)異常的代碼;
}catch(異常類名 變量名){異常處理代碼;
}

執(zhí)行流程：

程序從try里面的代碼開始執(zhí)行。
出現(xiàn)異常，會自動生成一個異常類對象，該異常對象將被提交給Java運行時系統(tǒng)。
當Java運行時系統(tǒng)接收異常對象時，會到catch中云找匹配的異常類，找到后進行異常的處理。
執(zhí)行完畢后，程序還可繼續(xù)往下執(zhí)行。

2.4、異常處理之try…catch…

public class ExceptionDemo {public static void main(String[] args) {System.out.println("開始");methood();System.out.println("異常處理完畢仍可繼續(xù)運行");}public static void methood(){try{int[] arr={1,2,3};System.out.println(arr[3]);}catch(ArrayIndexOutOfBoundsException e){System.out.println("數(shù)組下標越界");e.printStackTrace();}}}

2.5、Throwable的成員方法

方法名

說明

public String getMessage()

返回此throwable的詳細消息字符串

public String toString()

返回此可拋出的簡短描述

public void printStackTrace()

把異常的錯誤信息輸出在控制臺

2.6、編譯時異常和運行時異常的區(qū)別

Java中的異常被分為兩大類：編譯時異常和運行時異常，也被稱為受檢異常和非受檢異常。
所有的RuntimeException類及其子類被稱為運行時異常，其他的異常都是編譯時異常。

編譯時異常： 必須顯示處理，否則程序就會發(fā)生錯誤，無法通過編譯。
運行時異常： 無需顯示處理，也可以和編譯時異常一樣處理。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ExceptionDemo {public static void main(String[] args) {System.out.println("開始");methood();System.out.println("結束");}public static void methood(){try{String s="2000-01-01";SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");Date d=sdf.parse(s);}catch (ParseException e){e.printStackTrace();}}}

2.7、異常處理之throws

雖然可以通過try…catch…對異常處理，但并不是所有情況都有權限進行異常的處理。即，有些時候可能出現(xiàn)的異常我們處理不了。
針對這種情況，Java提供了throws的處理方案。

格式：

throws 異常類名;

注意：這個格式是跟在方法的括號后面的。

編譯時異常必須要進行處理，兩種處理方案：try...catch....或者throws，將來誰調(diào)用誰處理。

運行時異?？梢圆惶幚?#xff0c;出現(xiàn)問題后，需要回來修改代碼。

//編譯時異常
public static void methood() throws ParseException {       String s="2000-01-01";SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");Date d=sdf.parse(s);          
}//運行時異常
public static void methood1() throws ArrayIndexOutOfBoundsException{int arr[]={1,2,3};System.out.println(arr[3]);
}

2.8、自定義異常

格式：

public class 異常類名 extends Exception{無參構造帶參構造
}

示例：

自定義異常類

//自定義異常類
package com.test1;public class ScoreException extends Exception {public ScoreException(){}public ScoreException(String message){super(message);}
}

拋出異常。

package com.test1;public class Score{public static void check(int score) throws ScoreException{if(score<0||score>100){throw new ScoreException("分數(shù)不在0-100之間");}else{System.out.println("分數(shù)正常");}}
}

處理異常

package com.test1;import java.util.Scanner;public class ScoreDemo {public static void main(String[] args) {Scanner sc=new Scanner(System.in);System.out.println("請輸入分數(shù)：");int score=sc.nextInt();try{Score.check(score);}catch(ScoreException e){e.printStackTrace();}}}

注意：

運行時異常類繼承自：RuntimeException。
編譯時異常類繼承自Exception。

2.9、throws和throw的區(qū)別

throws

用在方法聲明后，跟的是異常類名。
表示拋出異常，由該方法的調(diào)用者來處理。
表示出現(xiàn)異常的一種可能性，并不一定發(fā)生這些異常。
throw
用在方法體內(nèi)，跟的是異常對象名。
表示拋出異常，由方法體內(nèi)的語句處理。
執(zhí)行throw一定拋出了某種異常。

3、集合進階

集合體系結構
在這里插入圖片描述

3.1、Collection

是單列集合的頂層接口，它表示一組對象，這些對象也稱為Collection的元素。
JDK不提供此接口的任何直接實現(xiàn)，它提供更具體的子接口實現(xiàn)，如Set和List。

創(chuàng)建Collection集合的對象：

多態(tài)的方式
具體的實現(xiàn)類ArrayList

import java.util.Collection;
import java.util.ArrayList;
public class CollectionDemo {
public static void main(String[] args) {
Collection c=new ArrayList();
c.add(“Hello”);
c.add(“world”);
System.out.println?;
}
}

Collection集合常用方法：

方法名

說明

boolea:n add(E e)

添加元素

boolean remove(Object o)

從集合中移除指定的元素

void clear()

清空集合中的元素

boolean contains(Object o)

判斷集合中是否存在指定的元素

boolean isEmpty()

判斷集合是否為空

int size()

集合的長度，也就是集合中元素的個數(shù)

Collection集合的遍歷：

Iterator：迭代器，集合的專用遍歷方式。
Iteratoriterator()：返回此集合中元素的迭代器，通過集合的iterator()方法得到。
迭代器是通過集合的iterator()方法得到的，所以我們說它是依賴于集合面存在的。

Iterator中的常用方法：

E next()：返回迭代中的下一個元素。
boolean hasNext()：如果迭代具有更多元素，則返回true

import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
public class CollectionDemo {
public static void main(String[] args) {
Collection c=new ArrayList();
c.add(“Hello”);
c.add(“world”);
c.add(“java”);
Iterator it=c.iterator();
while(it.hasNext()){
String s=it.next();
System.out.println(s);
}
```
}
```
}

3.2、List

3.2.1、List

List集合概述

有序集合（也稱序列），用戶可精確控制列表中每個元素的插入位置。用戶可通過索引訪問元素。
與Set集合不同，列表通常允許重復的元素。

List集合特點

有序：存儲和取出的元素順序一致。
可重復：存儲的元素可以重復。

List集合特有方法：

方法名

說明

void add(int index,E element)

在此集合中的指定位置插入指定的元素

E remove(int index)

刪除指定索引處的元素，返回被刪除的元素

E set(int index,E element)

修改指定索引處的元素，返回被修改的元素

E get(int index)

返回指定索引處的元素

示例：

import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
public class ListDemo {public static void main(String[] args) {List<String> list=new ArrayList<String>();list.add("Hello");list.add("world");list.add("java");//第一種遍歷：迭代器遍歷Iterator<String> it=list.iterator();while(it.hasNext()){String s=it.next();System.out.println(s);}//第二種遍歷：for循環(huán)方式for(int i=0;i<list.size();i++){String s=list.get(i);System.out.println(s);}}
}

3.2.2、List并發(fā)修改異常

并發(fā)修改異常

ConcurrentModificationException

產(chǎn)生原因

迭代器遍歷的過程中，通過集合對象修改了集合中元素的長度，造成了迭代器獵取元素中判斷預期修改值和實際值不一致。

解決方案：

用for循環(huán)遍歷，然后用集合對象做對應的操作即可。

import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
public class ListDemo {
public static void main(String[] args) {
List list=new ArrayList();
list.add(“Hello”);
list.add(“world”);
list.add(“java”);
//第一種遍歷：迭代器遍歷
Iterator it=list.iterator();
while(it.hasNext()){
String s=it.next();//觸發(fā)并發(fā)修改異常
if(s.equals(“world”)){
list.add(“aaa”);
}
}
//用for循環(huán)方式遍歷可解決List并發(fā)修改異常的問題：
for(int i=0;i<list.size();i++){
String s=list.get(i);
if(s.equals(“world”)){
list.add(“aaa”);
}
}
}
}

3.2.3、ListIterator

ListIterator列表迭代器

通過List集合的listIterator()方法得到，所以說它是List集合特有的迭代器。
可沿任一方向遍歷列表的列表迭代器，迭代期間修改列表，并獲取列表中迭代器的當前位置。

ListIterator中的常用方法：

E next()：返回迭代中的下一下元素。
boolean hasNext()：如果迭代具有更多元素，則返回true。
E previous()：返回列表中的上一個元素。
boolean hasPrevious()：如果此列表迭代器在相反方向遍歷列表時具有更多元素，則返回true。
void add(E e)：將指定的元素插入列表。

import java.util.List;
import java.util.ArrayList;
import java.util.ListIterator;
public class ListIteratorDemo {
public static void main(String[] args) {
List list=new ArrayList();
list.add(“hello”);
list.add(“world”);
list.add(“java”);
ListIterator lit=list.listIterator();
while(lit.hasNext()){
String s=lit.next();
System.out.println(s);
}
```
    System.out.println("---------");while(lit.hasPrevious()){String s = lit.previous();System.out.println(s);}
}
```
}

ListIterator不觸發(fā)并發(fā)修改異常

import java.util.List;
import java.util.ArrayList;
import java.util.ListIterator;
public class ListIteratorDemo {public static void main(String[] args) {List<String> list=new ArrayList<String>();list.add("hello");list.add("world");list.add("java");ListIterator<String> lit=list.listIterator();while(lit.hasNext()){String s = lit.next();if(s.equals("world"))lit.add("javaEE");}System.out.println(list);}
}

3.2.4、增加for循環(huán)

簡化數(shù)組和Collection集合的遍歷。
實現(xiàn)Iterable接口的類允許其對象成為增強型for語句的目標
JDK5之后出現(xiàn)，其內(nèi)部原理是一個Iterator迭代器。

增強for的格式：

for（元素的數(shù)據(jù)類型變量名:數(shù)組或者Collection集合）{//在此處使用變量即可，該變量就是元素。
}

示例：

int[] arr={1,2,3,4,5};
for(int i:arr){System.out.println(i);
}

3.2.5、數(shù)據(jù)結構

3.2.5.1、棧

先進后出。

3.2.5.2、列

先進先出。

3.2.5.3、數(shù)組

數(shù)組是一種查詢快，增刪慢的模型。
查詢數(shù)據(jù)通過索引定位，查詢?nèi)我鈹?shù)據(jù)耗時相同，查詢速度快。
刪除數(shù)據(jù)時，要將原始數(shù)據(jù)刪除，同時后面兩個數(shù)據(jù)前移，刪除效率低。
添加數(shù)據(jù)時，添加位置后的每人數(shù)據(jù)后移，再添加元素，添加效率極低。

3.2.5.4、鏈表

鏈表是一種增刪快的模型（對比數(shù)組）。
鏈表是一種查詢慢的模型（對比數(shù)組）。
查詢數(shù)據(jù)是否存在，必須從頭（head）開始查詢。

3.2.6、List集合子類特點

List集合常用子類：ArrayList、LinkedList

ArrayList：底層數(shù)據(jù)結構是數(shù)組，查詢快，增刪慢
LinkedList：底層數(shù)據(jù)結構是鏈表，查詢慢，增刪快。

ArrayList集合的三種遍歷方式

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.ListIterator;
public class test6 {public static void main(String[] args) {ArrayList<String> array=new ArrayList<String>();array.add("Hello");array.add("world");array.add("java");for(String s:array){System.out.println(s);}System.out.println("************");for(int i=0;i<array.size();i++){String s=array.get(i);System.out.println(s);}System.out.println("************");ListIterator<String> it=array.listIterator();while(it.hasNext()){String s=it.next();System.out.println(s);}System.out.println("************");while(it.hasPrevious()){String s=it.previous();System.out.println(s);}//LinkedList與ArrayList三種遍歷方法相同LinkedList<String> linkedList=new LinkedList<String>();linkedList.add("aaa");linkedList.add("bbb");linkedList.add("ccc");for(String s:linkedList){System.out.println(s);}}
}

3.2.7、LinkedList集合的特有功能

方法名

說明

puclic void addFirst(E e)

在該列表開頭插入指定的元素

public void addLast(E e)

將指定的元素追加到此列表的末尾

public E getFirst()

返回此列表中的第一個元素

public E getLast()

返回此列表中的最后一個元素

public E removeFirst()

從此列表中刪除并返回第一個元素

public E removeLast()

從此列表中刪除并返回最后一個元素

3.3、Set

3.3.1、Set集合概述和特點

Set集合特點

不包含重復元素的集合。
沒有帶索引的方法，所以不能使用普通for循環(huán)遍歷。

import java.util.Set;
import java.util.HashSet;
public class SetDemo {
public static void main(String[] args) {
Set set=new HashSet();
set.add(“Hello”);
set.add(“world”);
set.add(“java”);
```
    //沒有帶索引的方法，所以不能使用普通for循環(huán)遍歷//只能使用增強for循環(huán)遍歷for(String s:set){System.out.println(s);}
}
```
}

3.3.2、哈希值

哈希值： 是JDK根據(jù)對象的地址或者字符串或者數(shù)字計算出來的int類型的數(shù)值。

Object類中有一個方法可獲取對象的哈希值：

public int hashCode()：返回對象的哈希值。

對象的哈希值特點

同一個對象多次調(diào)用hashCode()方法返回的哈希值是相同的。
默認情況下，不同對象的哈希值是不相同的。
通過重寫Object中的hashCode方法，可以實現(xiàn)不同對象的哈希值是相同的。

3.3.3、HashSet集合添加一個元素的過程

在這里插入圖片描述
HashSet集合存儲元素：

要保證元素唯一性，需要重寫hashCode()和equals()

3.3.4、哈希表

JDK8之前，底層采用數(shù)組+鏈表實現(xiàn)，可以說是一個元素為鏈表的數(shù)組。
JDK8以后，在長度比較長的時候，底層實現(xiàn)了優(yōu)化。

3.3.5、LinkedHashSet

LinkedHashSet集合特點：

哈希表和鏈表實現(xiàn)的Set接口，具有可預測的迭代次序。
由鏈表保證元素有序，也就是說元素的存儲和取出順序是一致的。
由哈希表保證元素唯一，也就是說沒有重復的元素經(jīng)。

import java.util.LinkedHashSet;

public class LinkedHashSetDemo {
public static void main(String[] args) {
LinkedHashSet linkedHashSet=new LinkedHashSet();
linkedHashSet.add(“Hello”);
linkedHashSet.add(“world”);
linkedHashSet.add(“java”);
for(String s:linkedHashSet){
System.out.println(s);
}
}
}

3.3.6、TreeSet

TreeSet集合特點

元素有序，這里的順序不是指存儲和取出的順序，而是按照一定的規(guī)則進行排序，具體排序方式取決于構造方法。
- TreeSet()根據(jù)其元素的自然排序進行排序。
- TreeSet(Comparator comparator)根據(jù)指定的比較器進行排序
沒有帶索引的方法，所以不能使用普通for循環(huán)遍歷
由于是Set集合，所以不包含有重復元素的集合

import java.util.TreeSet;

public class TreeSetDemo {
public static void main(String[] args) {
TreeSet treeSet=new TreeSet();
treeSet.add(10);
treeSet.add(50);
treeSet.add(30);
treeSet.add(20);
treeSet.add(40);
for(Integer i:treeSet){
System.out.println(i);
}
}
}

3.3.7、自然排序Comparable的使用

存儲學生對象并遍歷，創(chuàng)建TreeSet集合使用無參構造方法。
要求：按照年齡從小到大排序，年齡相同時，按照姓名的字母排序。

結論：

Student類不實現(xiàn)Comparable接口，會觸發(fā)ComparablClassCastException異常。
實現(xiàn)Comparable接口就必須要實現(xiàn) compareTo?(T o)方法。

compareTo?(T o)方法的返回值:

返回0，會認為是重復元素不添加（添加的第一個元素除外）
返回正數(shù)，按存儲的順序正著輸出。

返回負數(shù)，按存儲的順序倒著輸出。

//Student.java
public class Student implements Comparable {
private String name;
private int age;

public Student(String name, int age) {this.name = name;this.age = age;
}public String getName() {return name;
}public void setName(String name) {this.name = name;
}public int getAge() {return age;
}public void setAge(int age) {this.age = age;
}@Override
public int compareTo(Student s){
/*return 0; //會認為是重復元素不添加進TreeSet（添加的第一個元素除外）return 1;//按存儲的順序升序輸出。return -1;//按存儲的順序倒著輸出。*//*//按照年齡從小到大排序return this.age-s.age;//按照年齡從大到小排序return s.age-this.age;*/int num=this.age-s.age;return num==0?this.name.compareTo(s.name):num;}

}

//TreeSetDemo.java
import java.util.TreeSet;

public class TreeSetDemo {
public static void main(String[] args) {
TreeSet treeSet=new TreeSet();
Student s1=new Student(“bbb”,20);
Student s2=new Student(“aaa”,20);
Student s3=new Student(“ccc”,21);
Student s4=new Student(“ddd”,30);
Student s5=new Student(“eee”,19);
treeSet.add(s1);
treeSet.add(s2);
treeSet.add(s3);
treeSet.add(s4);
treeSet.add(s5);
for(Student s:treeSet){
System.out.println(s.getName()+“,”+s.getAge());
}
}
}

用TreeSet集合存儲自定義對象，無參構造方法使用的是自然排序對元素進行排序的。
自然排序，就是讓元素所屬的類實現(xiàn)Comparable接口，重寫compareTo方法。
重寫方法時，一定要注意排序規(guī)則按要求的主要條件和次要條件來寫。

3.3.8、比較器排序Comparator的使用

用TreeSet集合存儲自定義對象，帶參構造方法使用的是比較器排序對元素進行排序。
比較器排序，就是讓集合構造方法接收Comparator的實現(xiàn)類對象。

重寫方法時，一定要注意排序規(guī)則必須按照主要條件和次要條件來寫。

//Studen.java
public class Student {
private int age;
private String name;

public Student( String name,int age) {this.age = age;this.name = name;
}public int getAge() {return age;
}public void setAge(int age) {this.age = age;
}public String getName() {return name;
}public void setName(String name) {this.name = name;
}

}

//TreeSetDemo.java
import java.util.TreeSet;
import java.util.Comparator;
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet treeSet=new TreeSet(new Comparator(){
@Override
public int compare(Student s1,Student s2){
int num=s1.getAge()-s2.getAge();
int num1=(0==num?s1.getName().compareTo(s2.getName()):num);

            return num1;}});Student s1=new Student("aaa",25);Student s2=new Student("bbb",19);Student s3=new Student("ddd",20);Student s4=new Student("ccc",20);treeSet.add(s1);treeSet.add(s2);treeSet.add(s3);treeSet.add(s4);for(Student s:treeSet){System.out.println(s.getName()+","+s.getAge());}
}

}

3.4、泛型

3.4.1、泛型概述

JDK5中引入的特性。
它提供了編譯時類型安全檢測機制，該機制允許在編譯時檢測到非法的類型，它的本質(zhì)是參數(shù)化類型，也就是說所操作的數(shù)據(jù)類型被指定為一個參數(shù)。
泛型類、泛型方法、泛型接口。

import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;

public class GenericDemo {
public static void main(String[] args) {
Collection c=new ArrayList();
c.add(“Hello”);
c.add(“world”);
Iterator it=c.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
}
}

3.4.2、泛型類

泛型的定義格式：

格式：修飾符 class 類名<類型>{}
范例：public class Generic<T> {}
此處T可以隨便定為任意標識，常見的如T、E、K、V

//Generic.java
public class Generic {
private T t;
```
public Generic(T t) {this.t = t;
}public T getT() {return t;
}public void setT(T t) {this.t = t;
}
```
}

GenericDemo.java
public class GenericDemo {
public static void main(String[] args) {
Generic g1=new Generic(“李淳罡”);
System.out.println(g1.getT());
Generic g2=new Generic(20);
System.out.println(g2.getT());
}

}

3.4.3、泛型方法

泛型方法定義格式：

格式：修飾符<類型> 返回值類型方法名(類型變量名){}
范例：pubcli <T> void show(T t){}

public class Generic{
public void show(T t){
System.out.println(t);
}
}

泛型方法改進：

public class Generic{public<T> void show(T t){System.out.println(t);}
}

3.4.4、泛型接口

泛型接口定義格式：

格式：修飾符 interface 接口名<類型>{}
范例：pubcli interface Generic<T>{}

public interface Generic {
void show(T t);
}

public class Genericlmpl implements Generic {
@Override
public void show(T t){
System.out.println(t);
}
}

public class Demo {
public static void main(String[] args) {
Generic g1=new Genericlmpl();
g1.show(“hello”);
Generic g2=new Genericlmpl();
g2.show(15);
}
}

3.4.5、類型通配符

類型通配符

為了表示各種泛型List的父類，可以使用類型通配符
類型通配符：<?>
List<?>：表示元素類型未知的List，它的元素可以匹配任何的類型
這種帶通配符的List僅表示它是各種泛型List的父類，并不能把元素添加到其中。

類型通配符上限
如果不希望List<?>是任何泛型List的父類，只希望它代表某一類型泛型List的父類，可以使用類型通配符的上限。

類型通配符上限：<extends 類型>
List<? extends Number>：它表示的類型是Number或者其子類型

類型通配符下限
除了可以指定類型通配符的上限，還可指定類型通配符的下限

類型通配符下限：<? super 類型>
List<? super Number>：它表示的類型是Number或者其父類型

import java.util.List;
import java.util.ArrayList;
public class Demo {
public static void main(String[] args) {
//類型通配符：<?> List<?> list1=new ArrayList();
List<?> list2=new ArrayList(); List<?> list3=new ArrayList();
System.out.println(““);
//通配符上限：<? extends 類型>
// List<? extends Number> list4=new List();//報錯，這里超過了上限
List<? extends Number> list5=new ArrayList();
List<? extends Number> List6=new ArrayList();
System.out.println(””);
//通配符下限：<? super 類型>
List<? super Number> list7=new ArrayList();
List<? super Number> list8=new ArrayList();
// List<? super Number> list9=new ArrayList();//報錯，這里超過了下限
```
}
```
}

3.4.6、可變參數(shù)

格式：修飾符返回值類型方法名(數(shù)據(jù)類型... 變量名){}
范例：public static int sum(int... a)

public class Demo {
public static void main(String[] args) {
System.out.println(sum(1));
System.out.println(sum(1,2));
System.out.println(sum(1,2,3));
}
public static int sum(int… arr){
int total=0;
for(int i:arr){
total+=i;
}
return total;
}
}

注意：

這里的變量a其實是一個數(shù)組
如果一個方法有多個參數(shù)，可變參數(shù)要放在最后。
```
public static int sum(int a,int... arr){return 0;
}  
```

3.4.7、可變參數(shù)的使用

Arrays工具類中有一個靜態(tài)方法：

public static<T> List<T> asList(T... a)：返回由指定數(shù)組支持的固定大小的列表。

返回的集合不能做增刪操作（增刪會改變長度），可以做修改操作。

import java.util.Arrays;
import java.util.List;	
public class Demo {public static void main(String[] args) {List<String> list= Arrays.asList("hello","world","java","hello");
//        list.add("aaa");//UnsupportedOperationException
//        list.remove("hello");//UnsupportedOperationExceptionlist.set(1,"aaa");System.out.println(list);}
}

List接品中有一個靜態(tài)方法：

public static<E> List<E> of(E... elements)：返回包含任意數(shù)量元素的不可變列表。

返回的集合不能做增刪改操作。

import java.util.List;public class Demo {public static void main(String[] args) {List<String> list= List.of("hello","world","hello");
//        list.add("aaa");//UnsupportedOperationException
//        list.remove("hello");//UnsupportedOperationException
//        list.set(1,"aaa");//UnsupportedOperationExceptionSystem.out.println(list);}
}

Set接口中有一個靜太方法：

public static<E> Set<E> of(E... elements)：返回一個包含任意數(shù)量元素的不可變集合。
不能給重復的元素。

返回的集合不能做增刪操作，沒有修改的方法。

import java.util.Set;public class Demo {public static void main(String[] args) {
//        Set<String> set= Set.of("hello","world","hello");//IllegalArgumentException,set中不能有重復元素Set<String> set= Set.of("hello","world");
//        set.add("aaa");//UnsupportedOperationException
//        set.remove("hello");//UnsupportedOperationExceptionSystem.out.println(set);}
}

3.5、Map

3.5.1、Map集合概述

Map集合概述

Interface Map<k,v> K：鍵的類型； V：值的類型。
將鍵映射到值的對象；
不能包含重復的鍵；
每個鍵可以映射到最多一個值。

創(chuàng)建Map集合對象

多態(tài)的方式
具體實現(xiàn)類HashMap

import java.util.HashMap;
import java.util.Map;

public class MapDemo {
public static void main(String[] args) {
Map<String,String> map=new HashMap<String,String>();
map.put(“001”,“唐僧”);
map.put(“002”,“孫悟空”);
map.put(“003”,“豬八戒”);
map.put(“003”,“沙悟凈”);//key重復，會被新的value覆蓋
System.out.println(map);
}
}

3.5.2、Map集合的基本功能

方法名

說明

V put(K key,V value)

添加元素

V remove(Object key)

根據(jù)鍵刪除鍵值對元素

void clear()

移除所有的鍵值對元素

boolean containsKey(Object key)

判斷集合是否包含指定的鍵

boolean containsValue(Object value)

判斷集合是否包含指定的值

boolean isEmpty()

判斷集合是否為空

int size()

集合的長度，即集合中鍵值對的個數(shù)

3.5.3、Map集合的獲取功能

方法名

說明

V get(Object key)

根據(jù)鍵獲取值

Set<K> keySet()

獲取所有鍵的集合

Collection<V> values()

獲取所有值的集合

Set<Map.Entry<K,v>> entrySet()

獲取所有鍵值對對象的集合

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class MapDemo {public static void main(String[] args) {Map<String,String> map=new HashMap<String,String>();map.put("張無忌","趙敏");map.put("郭靖","黃蓉");map.put("楊過","小龍女");System.out.println(map.get("楊過"));System.out.println("*************");Set<String> set=map.keySet();for(String key:set){System.out.println(key);}System.out.println("*************");Collection<String> values=map.values();for(String value:values){System.out.println(value);}System.out.println("*************");System.out.println(map);}
}

3.5.4、Map集合的遍歷

方式一：

import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class MapDemo {public static void main(String[] args) {Map<String,String> map=new HashMap<String,String>();map.put("張無忌","趙敏");map.put("郭靖","黃蓉");map.put("楊過","小龍女");//獲取所有鍵的集合Set<String> keys = map.keySet();for(String key:keys){String value=map.get(key);System.out.println(key+","+value);}}
}

方式二：

import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class MapDemo {public static void main(String[] args) {Map<String,String> map=new HashMap<String,String>();map.put("張無忌","趙敏");map.put("郭靖","黃蓉");map.put("楊過","小龍女");Set<Map.Entry<String, String>> entries = map.entrySet();for(Map.Entry<String,String> entry:entries){String key=entry.getKey();String value=entry.getValue();System.out.println(key+","+value);}}
}

3.5.5、HashMap的案例

創(chuàng)建一個HashMap集合，鍵是學生對象（Student），值是居住地（String）

要求保證唯一性：若學生對象成員變量值相同，認為是同一對象。

//Student.java
public class Student {
private String name;
private int age;

public Student(String name, int age) {this.name = name;this.age = age;
}public String getName() {return name;
}public void setName(String name) {this.name = name;
}public int getAge() {return age;
}public void setAge(int age) {this.age = age;
}@Override
public boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;if (age != student.age) return false;return name != null ? name.equals(student.name) : student.name == null;
}@Override
public int hashCode() {int result = name != null ? name.hashCode() : 0;result = 31 * result + age;return result;
}

}

//HashMapDemo.java
import java.util.HashMap;
import java.util.Set;

public class HashMapDemo {
public static void main(String[] args) {
HashMap<Student,String> hm=new HashMap<Student,String>();

    Student s1=new Student("孫悟空",30);Student s2=new Student("豬八戒",20);Student s3=new Student("沙悟凈",20);Student s4=new Student("孫悟空",30);/*s1和s4對象相同，value應該被覆蓋若要s1和s4對象相同，須重寫Student類的hashCode和equals*/hm.put(s1,"花果山");hm.put(s2,"高老莊");hm.put(s3,"流沙河");hm.put(s4,"水簾洞");//遍歷Set<Student> students = hm.keySet();for(Student s:students){String value=hm.get(s);System.out.println(s.getName()+","+s.getAge()+",住在"+value);}}

}

3.5.6、ArrayList中嵌套HashMap

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;public class ArrayListIncludeHashMap {public static void main(String[] args) {ArrayList<HashMap<String,String>> arrList=new ArrayList<HashMap<String,String>>();HashMap<String,String> hm1=new HashMap<String,String>();hm1.put("郭靖","黃蓉");hm1.put("楊過","小龍女");HashMap<String,String> hm2=new HashMap<String,String>();hm2.put("呂布","貂蟬");hm2.put("諸葛亮","黃月英");HashMap<String,String> hm3=new HashMap<String,String>();hm3.put("張無忌","趙敏");hm3.put("宋青書","周芷若");arrList.add(hm2);arrList.add(hm2);arrList.add(hm3);for(HashMap<String,String> hm:arrList){Set<String> keySet = hm.keySet();for(String key:keySet){String value=hm.get(key);System.out.println(key+","+value);}System.out.println("************");}}
}

3.5.7、HashMap中嵌套ArrayList

3.5.8、統(tǒng)計字符串中每個字符出現(xiàn)的次數(shù)

需求：

鍵盤錄入一個字符串，統(tǒng)計字符串中每個字符出現(xiàn)的次數(shù)。
舉例：錄入"aabbccdd"在控制臺輸出“a(2)b(2)c(2)”

思路：

鍵盤錄入一個字符串
創(chuàng)建HashMap集合，鍵是Character，值是Integer
遍歷字符串，得到每一個字符。

import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;

public class Demo {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println(“請輸入一個字符串”);
String line = sc.nextLine();
Map<Character,Integer> map=new TreeMap<Character,Integer>();
//遍歷字符串，得到每一個字符
for(int i=0;i<line.length();i++){
char key=line.charAt(i);
Integer value=map.get(key);
if(null==value){
map.put(key,1);
}else{
value++;
map.put(key,value);
}
}
```
    //遍歷HashMap集合StringBuilder sb=new StringBuilder();Set<Character> keySet = map.keySet();for(Character key:keySet){Integer value=map.get(key);sb.append(key).append("(").append(value).append(")");}System.out.println(sb.toString());
}
```
}

3.6、Collections

3.6.1、Collections的概述

是針對集合操作的工具類。

常用方法

public static <T extends Comparable<? super T>> void sort(List<T> list)：將指定的列表按升序排序。
public static void reverse(List<?> list)：反轉指定列表中元素的順序。
public static void shuffle(List<?> list)：使用默認的隨機源隨機排列指定的列表。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class CollectionsDemo {
public static void main(String[] args) {
List list=new ArrayList();
```
    list.add(3);list.add(4);list.add(1);list.add(6);list.add(5);list.add(2);//排序Collections.sort(list);System.out.println(list);//反轉list中的順序Collections.reverse(list);System.out.println(list);//洗牌Collections.shuffle(list);System.out.println(list);
}
```
}

3.6.2、對ArrayList排序

public class Student {private String name;private int age;public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;public class Demo {public static void main(String[] args) {ArrayList<Student> array=new ArrayList<Student>();Student s1=new Student("linqingxia",30);Student s2=new Student("zhangmanyu",35);Student s3=new Student("aaaaa",33);Student s4=new Student("bbbb",33);array.add(s1);array.add(s2);array.add(s3);array.add(s4);//使用Collectons對ArrayList集合排序Collections.sort(array, new Comparator<Student>() {@Overridepublic int compare(Student s1, Student s2) {//按照年齡排序int num=s1.getAge()-s2.getAge();int num2=num==0?s1.getName().compareTo(s2.getName()):num;return num2;}});for(Student s:array){System.out.println(s.getName()+","+s.getAge());}

查看全文

http://www.risenshineclean.com/news/55843.html