20172302 《Java軟件結構與數據結構》第四周學習總結

時間 2019-11-12

標籤 Java軟件結構與數據結構四周 4周學習總結欄目 Java 简体版

原文原文鏈接

2018年學習總結博客總目錄：第一週第二週第三週第四周
html

教材學習內容總結

第六章列表

1.列表是對象的有序集合，在 List 界面中定義。 List 接口表示集合框架中的列表。列表能夠具備重複的元素。而且咱們能夠在列表中存儲多個空值。前端

2.列表集合是一種概念性的表示方法，其思想是使事物以線性列表的方式進行組織，就像棧和隊列同樣，列表也可使用數組和鏈表來實現。列表集合沒有內在的容量大小，它能夠隨着須要而增大。列表集合更通常化，能夠在列表的中間和末端添加和刪除元素。java

3.列表能夠分爲有序列表、無序列表、索引列表。git

有序列表，是基於列表中元素的某種特性的。列表基於某個關鍵值排序，對於已經添加到有序列表中的元素，只要給定了元素的關鍵值，同時列表已經定義了元素的全部關鍵值，那麼它在列表中就有一個固定的位置。
無序列表，各個元素的位置並不基於元素的任何內在特性，可是不要被名字誤導，無序列表中的元素是按照特殊順序放置，只是這種順序與元素自己無關，列表的使用者會決定列表的順序。
索引列表，與無序列表相似，索引列表的各個元素之間也不存在可以決定他們在列表中順序的內在關係。列表的使用者決定了元素的順序，不過，除此以外，其每一個元素都可以從一個數字索引值獲得引用，該索引值從列表的頭開始從0連續增長直到列表末端。當列表發生改變，索引值就響應的調整以保持順序和連續性。索引列表爲他的元素維護一段連續的數字索引值。

4.列表的整體UML圖
數據庫

5.Java集合API中的列表所定義的一些基本操做，見下表數組

操做	描述
add	向列表末端添加一個元素
add(int index, E element)	在列表的指定位置插入指定元素
get(int index)	返回列表中指定位置的元素
remove(int index)	移除列表中指定位置的元素
remove(Object o)	今後列表中移除第一次出現的指定元素（若是存在）
set(int index, E element)	用指定元素替換列表中指定位置的元素
size()	返回列表中的元素數

6.①無序列表的使用：學習計劃；②索引列表的使用：Josephus問題。網絡

7.列表ADT
（1）列表的常見操做數據結構

操做	描述
removeFirst	從列表中刪除第一個元素
removeLast	從列表中刪除最後一個元素
remove	從列表中刪除某個元素
first	查看位於列表前端的元素
last	查看位於列表末端的元素
isEmpty	肯定列表是否爲空
size	肯定列表中的元素數

（2）接口ListADT的代碼app

import java.util.Iterator;

public interface ListADT<T> extends Iterable<T>
{
   
    public T removeFirst();

   
    public T removeLast();


    public T remove(T element);

 
    public T first();

   
    public T last();

    public boolean contains(T target);

   
    public boolean isEmpty();

 
    public int size();

  
    public Iterator<T> iterator();

    public String toString();
}

（3）有序列表接口類代碼框架

public interface OrderedListADT<T> extends ListADT<T>
{
  
    public void add(T element);
}

（4）無序列表接口類代碼

public interface UnorderedListADT<T> extends ListADT<T>
{
    
    public void addToFront(T element);  

  
    public void addToRear(T element); 


    public void addAfter(T element, T target);
}

8.使用數組實現列表

ArrayList類的頭和類級代碼：

public abstract class ArrayList<T> implements ListADT<T>, Iterable<T>
{
    private final static int DEFAULT_CAPACITY = 100;
    private final static int NOT_FOUND = -1;
    
    protected int rear;
    protected T[] list; 
    protected int modCount;


    public ArrayList()
    {
        this(DEFAULT_CAPACITY);
    }

   
    public ArrayList(int initialCapacity)
    {
        rear = 0;
        list = (T[])(new Object[initialCapacity]);
        modCount = 0;
    }
}

remove操做及find方法

public T remove(T element)
    {
        T result;
        int index = find(element);

        if (index == NOT_FOUND)
            throw new ElementNotFoundException("ArrayList");

        result = list[index];
        rear--;
        
        // shift the appropriate elements 
        for (int scan=index; scan < rear; scan++)
            list[scan] = list[scan+1];
 
        list[rear] = null;
        modCount++;

        return result;
    }
private int find(T target)
    {
        int scan = 0; 
        int result = NOT_FOUND;
 
        if (!isEmpty())
            while (result == NOT_FOUND && scan < rear)
                if (target.equals(list[scan]))
                    result = scan;
                else
                    scan++;

        return result;
    }

contains操做：這裏也將調用find方法

public boolean contains(T target)
    {
        return (find(target) != NOT_FOUND);
    }

添加操做

有序列表的add操做

public void add(T element)
  {
      if (!(element instanceof Comparable))
          throw new NonComparableElementException("OrderedList");

      Comparable<T> comparableElement = (Comparable<T>)element;

      if (size() == list.length)
          expandCapacity();

      int scan = 0;  

      // find the insertion location
      while (scan < rear && comparableElement.compareTo(list[scan]) > 0)
          scan++;

      // shift existing elements up one
      for (int shift=rear; shift > scan; shift--)
          list[shift] = list[shift-1];

      // insert element
      list[scan] = element;
      rear++;
      modCount++;
  }

無序列表的addAfter操做

public void addAfter(T element, T target)
  {
      if (size() == list.length)
          expandCapacity();

      int scan = 0;

      // find the insertion point
      while (scan < rear && !target.equals(list[scan])) 
          scan++;

      if (scan == rear)
          throw new ElementNotFoundException("UnorderedList");

      scan++;

      // shift elements up one
      for (int shift=rear; shift > scan; shift--)
          list[shift] = list[shift-1];

      // insert element
      list[scan] = element;
      rear++;
      modCount++;
  }

9.使用鏈表實現列表

LinkedList類的類頭、類級函數和構造函數：

public abstract class LinkedList<T> implements ListADT<T>, Iterable<T>
{
    protected int count;
    protected LinearNode<T> head, tail;
    protected int modCount;
    
    /**
     * Creates an empty list.
     */
    public LinkedList()
    {
        count = 0;
        head = tail = null;
        modCount = 0;
    }
}

教材學習中的問題和解決過程

問題1：對於書上97頁所說起的「Serializable接口是爲了某個對象能使用串行化進行存儲」，什麼是串行化，又是怎麼實現的？
問題1解決方案：（1）Java串行化即Java序列化，一個對象隨着建立而存在，隨着程序結束而結束。那若是我要保存一個對象的狀態呢？Java序列化可以將對象的狀態寫入byte流存儲起來，也從其餘地方將byte流讀取出來，從新構造一個新的對象。這種機制容許你將對象經過網絡進行傳播，而且能夠隨時把對象持久化到數據庫、文件系統中。簡而言之，序列化就是將一個對象的狀態保存起來，而反序列化就是將已經保存的流對象恢復成原來的對象。
（2）如何實現序列化？
實現序列化有一個條件，即實現序列化的類必須實現java.io.Serializable接口。以後能夠利用ObjectInputStream的readOjbect()方法和OjbectOutputStream的writeObject()方法進行對象的讀和寫，即反序列化和序列化。

a) Java對象：在java中要想使一個java對象能夠實現序列化與反序列化,必須讓該類實現java.io.Serializable接口，java.io.Serializable接口定義以下:

publicinterface Serializable {

}

b) 序列化主要依賴java.io.ObjectOutputStream類,該類對java.io.FileOutputStream進一步作了封裝,這裏主要使用ObjectOutputStream類的writeObject()方法實現序列化功能

/**

     *將對象序列化到磁盤文件中

     *@paramo

     *@throwsException

     */

    publicstaticvoid writeObject(Object o) throws Exception{

       File f=new File("d:""user.tmp");

       if(f.exists()){

           f.delete();

       }

       FileOutputStream os=new FileOutputStream(f);

       //ObjectOutputStream 核心類

       ObjectOutputStream oos=new ObjectOutputStream(os);

       oos.writeObject(o);

       oos.close();

       os.close();

    }

代碼調試中的問題和解決過程

問題1：Josephus問題中的代碼中numPeople，skip分別表明什麼意思？
問題1解決方案：把書上代碼敲入後，運行了兩次，去對比書上給出的那個7個元素的結果，

這時即可理解numPeople表明總的人數，而skip表明的則是每隔幾個元素刪除一個元素，每3我的在這裏其實是每隔2我的。
問題2：作PP6.17時，關於compareTo方法如何去編寫遇到了些問題
問題2解決方案：要求是首先按照系排序課程，再按照課程號排序，一開始我是想在Course類下的compareTo方法中只進行系排序，再到實現add方法時再進行課程號排序，可這樣始終不行，作起來也很麻煩，最後是在Course類下的compareTo方法中直接用1和-1來表示按照系、課程號排序的一個值，在add方法直接進行排序。
compareTo方法：

if (prefix.compareTo(course.prefix) > 0)
        {
            return 1;
        }
        else
        {
            if (prefix.compareTo(course.prefix) < 0)
            {
                return -1;
            }
            else
            {
                if (number > course.number)
                {
                    return 1;
                }
                else
                {
                    return -1;

                }
            }
        }

add方法：

public void addCourse(Course course)
    {
        int i=0;
        for(Course course1:list)
        {
            if (course1.compareTo(course)<0)
                i++;
        }

        list.add(i,course);
    }