Java中復合數據類型怎么用

這篇文章主要為大家展示了“Java中復合數據類型怎么用”，內容簡而易懂，條理清晰，希望能夠幫助大家解決疑惑，下面讓小編帶領大家一起研究并學習一下“Java中復合數據類型怎么用”這篇文章吧。

1、Java字符串

在 Java 中字符串被作為 String 類型的對象處理。 String 類位于 java.lang 包中，默認情況下該包自動導入。

String對象創建后不會被修改，當我們修改某個字符串對象實際上是將原引用指向了新創建的內存空間。并且相同的字符串常量Java不會分配兩個內存空間，而是將兩個引用指向相同的空間。

public class MyString {
    public static void main(String[] args) {
        String s1="字符串";
        String s2="字符串";
        String s3=s1;
        System.out.println(s1==s2);     // s1、s2字符串內容相同，指向相同的內存空間，輸出：true
        System.out.println(s1==s3);     // 修改之前s1與s3相同，輸出：true
        s1="修改字符串";
        System.out.println(s1==s3);     // 修改之后s1指向新的內存空間，與s3不同，輸出：false
    }
}

String中常用的方法：

str.length()    //返回當前字符串的長度
str.indexOf(int ch)    //查找ch字符在該字符串中第一次出現的位置，若無返回-1
str.indexOf(subStr)    //查找str子字符串在該字符串中第一次出現的位罝
str.lastIndexOf(ch)    //查找ch字符在該字符串中最后一次出現的位置
str.lastlndexOf(subStr)查找St子字符串在該字符串中最后一次出現的位置
str.substring(beginlndex)    //獲取從beginlndex位置幵始到結朿的子字符串
str.substring(beginlndex, endlndex)    //獲取從beginlndex位置幵始到endlndex位M的子字符串
str.trim()        //返回去除了前后空格的字符串
str.equals(obj)        //將該字符串與指定對象比較，返回true或false
str.toLowerCase()        //將字符串轉換為小寫
str.toUpperCase()        //將字符串轉換為大寫
str.charAt(int index)    //獲取字符串中指定位置的字符
str.setCharAt(i,c)    //設置某個位置的字符串
str.split(String regex, int limit)        //將字符串分割為子字符串，返回字符串數組
str.concat(str2)        //將str2拼接到末尾
str.getBytes()        /將該字符串轉換為byte數組
str.toCharArray()        //轉化為字符數組

如果需要使用經常修改的字符串，可以用StringBuilder類來保存，可以通過append、replace等方法對字符串進行修改，修改之后仍然指向同一塊內存地址

public class MyString {
    public static void main(String[] args) {
        StringBuilder s4=new StringBuilder("初始字符串");
        StringBuilder s5=s4;
        s4.replace(0,10,"修改后的字符串");
        System.out.println(s4);
        System.out.println(s4==s5);     // 修改后仍然指向同一塊內存，因此輸出：true
    }
}

通過String.valueOf()可以將其他類型數據轉化為字符串。

char[] arr={'a', 'd', 'e'};
String s=String.valueOf(arr);

2、Java中的包裝類

Java中的基本數據類型如int、double等都不具有對象的特性，為了像其他對象一樣擁有自己的方法，Java為每個基本數據類型提供了包裝類，像對象那樣來操作基本數據類型。包裝類的基本方法用于實現類型之間的相互轉換。

Java包裝類可以自動裝箱/拆箱，即通過=運算符自動完成基本類型和包裝類之間的類型轉換。

// 定義int類型變量，值為86
		int score1 = 86;       
		// 使用int創建Integer包裝類對象，手動裝箱
		Integer score2=new Integer(score1);  
                Integer score2=score1;    //自動裝箱      
		// 將Integer包裝類轉換為double類型
		double score3=score2.doubleValue();        
		// 將Integer包裝類轉換為float類型
		float score4=score2.floatValue();        
		// 將Integer包裝類轉換為int類型，手動拆箱
		int score5 =score2.intValue();	
                int score5 = score2        // 自動拆箱	
		// 將字符串轉為int
		int score6 = Integer.parseInt("666");

基本類型與字符串之間的互相轉換：

通過Integer.MAX_VALUE可以獲得最大整數值

使用 java.util 包中的 Date 類可以創建時間對象，使用java.text 包中的 SimpleDateFormat 類可以將時間轉化為所需格式的字符串，其中 “yyyy-MM-dd HH:mm:ss” 為預定義字符串， yyyy 表示四位年， MM 表示兩位月份， dd 表示兩位日期， HH 表示小時(使用24小時制)， mm 表示分鐘， ss 表示秒，這樣就指定了轉換的目標格式，最后調用 format() 方法將時間對象Date轉換為指定的格式的字符串，反之parse()方法可以將普通字符串轉化為Date對象。

java.util.Calendar 類可以更加方便地進行時間的處理，通過調用 getInstance() 靜態方法獲取一個 Calendar 對象，默認代表當前時間，可以通過c.getTime()將其轉化為Date對象。Calendar對象的更多方法如下

Math 類位于 java.lang 包中，包含用于執行基本數學運算的方法， Math 類的所有方法都是靜態方法，所以使用該類中的方法時，可以直接使用類名.方法名，如： Math.round();

int minNum=Math.min(2, 3);    //獲取最小值
int maxNum=Math.max(2, 3);    //獲取最大值
 
long round=Math.round(3.1415);      //四舍五入
double floor=Math.floor(3.1415);    //向下取整
double ceil=Math.ceil(3.1415);      //向上取整
double random=Math.random();        //取[0,1)之間的隨機數

3、Java容器

在各種基本數據類型的基礎上，Java使用集合類當作容器來儲存具有相同屬性的對象。通過集合類組織數據可以實現對特定數據的快速插入、刪除與查詢操作。而且與數組相比，集合的長度靈活可變，而且查找方式也不只有下標一種。Java中常見的集合類分為兩個接口Collection和Map，其中Collection有三個子接口鏈表List、隊列Queue、集Set，List常見的實現類為數組序列ArrayList，Queue實現類為LinkedList稱為鏈表，Set實現類為哈希集。Collection中按照一個一個對象來存儲數據，Map中按照鍵值對<key,value>來存儲數據。

Collection接口規定了ArrayList、Set等具體實現類的接口方法，例如它們都使用add()方法來添加元素，因此一些方法名在各個類實現中是通用的。

ArrayList

ArrayList是類似于數組的容器，將對象儲存進ArrayList之中便于組織和管理。通過add()方法可以將單個對象插入列表，addAll()可以將多個對象組成的子列表插入父列表中，插入時可以指定插入的位置，可以通過Arrays.asList()將數組轉化為列表，通過toArray()方法可以將列表轉為Object[]數組，可以向其中傳入泛型參數從而返回特定類型的數組。

需要注意的是通過Arrays.asList()轉化成的List長度是固定的，不能進行add()操作，會報錯；我們可以將其作為子列表添加到一個新的List列表，然后再進行插入操作。

例如向列表courseList中插入Course對象：

public void addCourse(){
    Course c1=new Course(1,"數據結構");
    Course c2=new Course(2,"操作系統");
    Course[] cArr={new Course(3,"組成原理"),new Course(4,"計算機網絡")};
 
    courseList.add(c1);                         // 向數組列表中添加對象
    courseList.add(0,c2);                 // 向指定位置添加對象
    courseList.addAll(Arrays.asList(cArr));     // 向列表中添加子列表，前加數字表示插入位置
    Course tmp=(Course)courseList.get(0);       // 從列表中取出對象
    Course[] courseArr=courseList.toArray(new Course[courseList.size()]);    // 轉換為特定類型的數組
}

特別地，int[]與List<Integer>之間無法直接使用asList()/toArray()方法進行互相轉換，可以經過如下流操作，或者遍歷int[]逐個添加到List

int[] nums=new int[]{3,1,5,8};
//arr轉list
List<Integer> numList = Arrays.stream(nums).boxed().collect(Collectors.toList());
//list轉arr
int[] arr = numList.stream().mapToInt(Integer::valueOf).toArray();

通過size()方法可以獲取列表長度，通過get()方法可以獲取指定位置的對象，進而通過for循環遍歷每個對象，也可以使用for each的方式遍歷每個元素。還可以通過迭代器實現對每個對象的訪問。值得注意的是，每個對象在列表中都是以Object對象的方式儲存的，因此在取出之后需要通過強制類型轉換為原來的對象類型，例如(Course)轉為Course類的對象

public void showCourse(){
        int listLength=courseList.size();           // 獲取列表長度
        for (int i=0;i<listLength;i++) {
            Course c=(Course)courseList.get(i);     // 獲取列表第i個元素
            System.out.println(c.name);
        }
    }
 
    public void iteratorCourse(){
        Iterator it=courseList.iterator();          // 獲取迭代器
        while (it.hasNext()){                       // 如果仍有下一個元素
            Course c=(Course)it.next();             // 取出下一個元素
            System.out.println(c.name);
        }
    }

通過set()方法對列表指定位置的元素進行修改。通過remove()方法移除指定位置或者指定對象。通過removeAll()刪除父列表中包含的所有子列表中的元素，通過clear()可以清空列表。

public void modifyCourse(){
        courseList.set(2,new Course(5,"離散數學"));     // 修改2位置上的對象
    }
 
    public void removeCourse(){
        courseList.remove(3);               // 刪除3位置上的對象
        Course c1= (Course) courseList.get(1);
        Course c2=(Course) courseList.get(2);
        courseList.remove(c1);                      // 刪除指定對象
        Course[] cArr={c1,c2};
        courseList.removeAll(Arrays.asList(cArr));  // 刪除courseList中所包含的cArr的元素
    }

通過contains()、containsAll()方法判斷List是否包含某個或者某幾個對象，其實現原理是遍歷List中的每個對象調用其equals()方法和目標對象進行比較，如果存在返回true，否則返回false。因此我們可以重寫Course類的equals()方法，進而調用contains()方法判斷List中是否包含指定Course對象。類似地indexOf()方法可以通過調用equals()找到元素在List中第一次出現的位置。

// 重寫Course類的equals()方法
    public boolean equals(Object o) {
        if (this == o) return true;     // 如果兩個對象的地址相同，肯定相同
        if (!(o instanceof Course)) return false;
        Course course = (Course) o;
        return id == course.id &&       // 判斷兩個Course對象的id和name相同
                name.equals(course.name);
    }
 
    // 在CourseList中調用contains()判讀是否包含某個對象
    public void containCourse(){
        Course nc=new Course(5,"數據結構");
        if(courseList.contains(nc)) {                     // 判斷List中是否包含Course對象nc
            int index = courseList.indexOf(nc);           // 獲取元素在List中的位置
            System.out.println("列表中包含該課程，位置：" + index);
        }
    }

之前提到集合中存放的都是對象的引用(Object)，每次存入時集合會忽略對象的具體類型，有時存入其他類型對象則會在運行時出錯，而且每次取出時則需要進行類型的強制轉換還原回來。可以使用泛型規定某個集合只能存放特定類型或者其子類型的對象，這樣就會在編譯期間進行類型檢查，而且在取出時可以直接返回特定類型的對象。注意泛型不能用于基本數據類型，例如List <int>會報錯，而應該使用其包裝類List <Integer>。

// 創建元素類型為Course的列表
    public List<Course> courseList=new ArrayList<Course>(); 
    public void addCourse(){
        Course c=new Course(6,"數據結構");
        courseList.add(c);
//        courseList.add("字符串");    // 嘗試向列表中添加非Course類型的對象，報錯
        Course c2=courseList.get(0);        // 可以直接取出為Course類型對象
        System.out.println(c2.name);
    }

通過集合的工具類Collections.sort()方法可以實現對List對象的排序，其實現的原理是調用每個元素的compareTo()方法實現對象之間的比較進而排序。因此每個對象必須是可比較的類型，即必須實現了Comparable 接口的對象，如下所示首先定義可比較類Student，再定義學生列表studentLis添加學生對象后，調用Collections.sort()方法對列表進行排序，或者直接使用studentList.sort()。

public class Student implements Comparable<Student> {   // 定義Student類實現Comparable接口
    public String name;
    public int id; 
    public Student(int id, String name) {
        this.name = name;
        this.id = id;
    }
 
    @Override
    public int compareTo(Student o) {        // 實現接口的方法，根據id大小對學生進行比較
        if (this.id>o.id){          // 如果大于o返回1
            return 1;
        }else if (this.id<o.id){    // 小于返回-1
            return -1;
        }else {                     // 等于返回0
            return 0;
        }
    }
}
 
public class ListSort {
    public List<Student> studentList=new ArrayList<Student>();    // 學生列表 
    public void sortStudent(){
        Student s1=new Student(1011,"小明");
        Student s2=new Student(1005,"小趙");
        Student s3=new Student(1021,"小錢");
        Student[] sArr={s1,s2,s3};
        studentList.addAll(Arrays.asList(sArr));
        Collections.sort(studentList);                // 調用方法對學生列表進行排序
        for (Student s:studentList) {
            System.out.println(s.id+":"+s.name);
        }
    }
}

也可以在調用sort()方法時傳入一個自定義的比較器對象Comparator，通過重寫compare()方法來實現兩個對象的比較。這里很明顯可以看到上面的Comparable接口是被比較對象自身實現的，用于自身和其他對象比較；而Comparator是第三方對象實現的接口，用于比較兩個對象。

// 自定義比較器類來實現兩個Student對象的比較
public class StudentComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        if (o1.id>o2.id){          // 如果大于o返回1
            return 1;
        }else if (o1.id<o2.id){    // 小于返回-1
            return -1;
        }else {                     // 等于返回0
            return 0;
        }
    }
} 
// 調用sort()方法時傳入比較器
Collections.sort(studentList,new StudentComparator());

HashSet

哈希集是Set的一個實現類，與list不同，set中的元素是無序且不可以重復的。

和List一樣，在Set中通過add()、remove()等方法實現元素的增加刪除等操作。由于Set是無序的，因此沒有set()、get()方法實現在指定位置插入/獲取元素，在遍歷元素時通過for each、iterator來實現，而且每次遍歷的結果順序是不確定的。

注意HashSet中的contains()方法會首先調用對象的hashCode()方法比較哈希碼，再調用equals()方法，兩個都為true才會認為兩個對象相同。

例如通過HashSet來存儲學生所選課程

public class Student {
    public String name;
    public int id;
    public Set<Course> courses;     // 用set保存學生所選課程 
    public Student(int id, String name) {
        this.name = name;
        this.id = id;
        this.courses=new HashSet<Course>();     //創建Hash集
    }
 
    public static void main(String[] args){
        Course c=new Course(1,"數據結構");
        Student s=new Student(101,"小明");     
        s.courses.add(c);               // 向集中添加對象
        for (Course course:s.courses) {         // 遍歷集
            System.out.println(course.name);
        }
    }
}

HashMap

Map以一一對應的鍵值對<key,value>的形式儲存數據，通過映射關系可以實現key快速查找value，key值不能重復。Map也支持泛型Map<K,V>，注意K，V不能是Java類，而是包裝類。

通過put(key,value)向Map中添加鍵值對，get(key)通過鍵獲取值，remove(key)移除鍵。修改Map鍵值對也使用put()方法，新的鍵值對會覆蓋原有的值。通過containsKey(key)方法可以返回Map中是否包含某個key值，containsValue(value)返回Map中是否包含某個值，它通過調用對象的equals()方法比較來返回是否存在。

還可以通過keySet()、values()、entrySet()方法分別獲取Map的鍵、值、鍵值對，返回的鍵值對Entry仍然可以定義泛型類型。

// 創建存儲學生類的哈希Map
    public Map<Integer,String> studentMap=new HashMap<Integer, String>(); 
    public void addStudent(){
        Scanner input=new Scanner(System.in);
        System.out.print("請輸入學生ID：");
        int studentID=input.nextInt();
        String s=studentMap.get(studentID);        // 根據key值獲取對應的value
        if (s!=null){                              // 如果s不為空說明該key已經存在
            System.out.println("該學生ID已存在！");
        }else {
            System.out.print("請輸入姓名：");
            String name=input.next();
            studentMap.put(studentID,name);     // 將<ID,name>鍵值對添加到Map中
        }
    }
 
    public void showStudent(){            //通過foreach遍歷HashMap
        // 獲取Map的鍵值對Entry并對其泛型進行定義
        Set<Map.Entry<Integer,String>> entrySet=studentMap.entrySet();
        for(Map.Entry<Integer,String> entry:entrySet){
            int key= entry.getKey();                    // 從Entry中獲取key
            String name=entry.getValue();               // 從Entry中獲取value
            System.out.println(key+":"+name);
        }
    }
 
    public void showStudent2(){            //通過迭代器遍歷HashMap
    　　Iterator iter = studentMap.entrySet().iterator();
　　    while (iter.hasNext()) {
　　        Map.Entry entry = (Map.Entry) iter.next();
　　        Int key= entry.getKey();
　　        String name = entry.getValue();
            System.out.println(key+":"+name);
        }
　　}

4、工具類

Stack

棧的創建和簡單使用如下所示

Stack<Integer> st = new Stack<>();      //新建棧
        st.push(3);
        int peek=st.peek();     //獲取棧頂元素
        System.out.println(peek);
        int pop=st.pop();       //彈出棧頂元素
        System.out.println(pop);
        System.out.println(st.empty());     //判斷棧是否為空

Queue

LinkedList類實現了Queue接口，因此我們可以把LinkedList當成Queue來用。隊列的使用如下

Queue<Integer> queue = new LinkedList<>();    //創建并初始化隊列
        queue.offer(1);     //元素入隊
        queue.offer(3);
        queue.offer(5);
        
        for(int num:queue)      //遍歷隊列
            System.out.println(num);
        int pNum=queue.peek()    //獲取第一個元素
        int qNum=queue.poll();  //元素出隊
        System.out.println(qNum);

以上是“Java中復合數據類型怎么用”這篇文章的所有內容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內容對大家有所幫助，如果還想學習更多知識，歡迎關注億速云行業資訊頻道！