溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要介紹“JAVA中int類型數組怎么修改為泛型”，在日常操作中，相信很多人在JAVA中int類型數組怎么修改為泛型問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”JAVA中int類型數組怎么修改為泛型”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！
先來一個簡單的內容，這個是正常的，以為我在日常的開發中有的時候還是能遇見的，哈哈哈哈，正不正常就以我是不是用過作為標準
public class Main {
public static void main(String[] args) {
Array score=new Array(10);
for(int i=0;i<8;i++){
score.addLast(i);
}
score.add(1,100);
score.addLast(99);
System.out.println(score.toString());
System.out.println(score.find(1));
System.out.println(score.contains(1));
System.out.println(score.remove(1));
System.out.println(score.toString());
System.out.println(score.removeElement(2));
System.out.println(score.toString());
}
}public class Array<T> {
private T[] data;
private int size;
public Array() {
this(10);
}
public Array(int capacity) {
//java本身不支持直接new 一個泛型數組，所以用以下方法實現
data = (T[])new Object[capacity];
size = 0;
}
public int getSize() {
return size;
}
public int getCapacity() {
return data.length;
}
public boolean isEmpty() {
return size == 0;
}
/**
* 向數組末尾添加元素
*
* @param e
*/
public void addLast(T e) {
add(size, e);
}
/**
* 向數組開頭添加元素
*
* @param e
*/
public void addFirst(T e) {
add(0, e);
}
/**
* 向任意合法位置添加元素
*
* @param index
* @param e
*/
public void add(int index, T e) {
if (size == data.length) {
throw new IllegalArgumentException("Add is fail.Array is full");
}
if (index < 0 || index > size) {
throw new IllegalArgumentException("Add is fail.Require index >= 0 and index < size");
}
for (int i = size; i > index; i--) {
data[i] = data[i - 1];
}
data[index] = e;
size++;
}
/**
* 獲取索引位置的元素
* 通過這種封裝，用戶無法查詢未使用的空間，保證了數據的安全性。
*
* @param index
* @return
*/
public T get(int index) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("Get is failed.Index is illegal");
}
return data[index];
}
/**
* 修改索引位置的元素
*
* @param index
* @param e
*/
public void set(int index, T e) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("Set is failed.Index is illegal");
}
data[index] = e;
}
/**
* 數組中是否包含某個元素
*
* @param e
* @return
*/
public boolean contains(T e) {
for (int i = 0; i < size; i++) {
//注意值的比較應修改為equals方法
if (data[i].equals(e)) {
return true;
}
}
return false;
}
/**
* 查詢數組中某個元素的索引
*
* @param e
* @return 沒有該元素則返回-1
*/
public int find(T e) {
for (int i = 0; i < size; i++) {
if (data[i].equals(e)) {
return i;
}
}
return -1;
}
/**
* 刪除index位置的元素，并且返回該元素
* 不用擔心刪除后原來size位置的元素，因為用無法訪問到它。
* 但是最好再寫一句data[size]=null 具體原因需要了解java的垃圾回收機制
*
* @param index
* @return
*/
public T remove(int index) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("Remove failed.Require index >=0 and index < size");
}
T ret = data[index];
for (int i = index; i < size - 1; i++) {
data[i] = data[i + 1];
}
//注意維護size
size--;
data[size]=null;
return ret;
}
/**
* 不用擔心數組為空的情況，因為數組如果為空,remove方法就會拋出異常
* @return
*/
public T removeFirst(){
return remove(0);
}
public T removeLast(){
return remove(size-1);
}
/**
* 從數組中刪除元素e
* @param e
*/
public boolean removeElement(T e){
int index=find(e);
if(index!=-1){
remove(index);
return true;
}else{
return false;
}
}
/**
* 重寫toString()方法
*
* @return
*/
@Override
public String toString() {
StringBuilder res = new StringBuilder();
res.append(String.format("size= %d,capacity= %d\n", size, data.length));
res.append("[");
for (int i = 0; i < size; i++) {
res.append(data[i]);
if (i != size - 1) {
res.append(",");
}
}
res.append("]");
return res.toString();
}
}
前面當我們向數組中添加元素時，如果index==size，表示數組已滿。
if (size == data.length) {
throw new IllegalArgumentException("Add is fail.Array is full");
}
123現在可以考慮這樣做，依然判斷插入位置是否合法，但是當size等于數組長度時，自動為數組擴容——resize(2*data.length);
之所以是擴為原來的2倍，是因為這樣擴容量的大小和原來容量大小有關，既不會過小也不會過大。
private void resize(int newCapacity){
T[] newData=(T[])new Object[newCapacity];
for(int i=0;i<size;i++){
newData[i]=data[i];
}
data=newData;
}
1234567因為有了resize方法，實現起來就很簡單了。在remove(int index)方法中，移除一個元素且維護size后，再加上對維護后的size的判斷，如下。如果size已經變為capacity的一半，則將數組容量減半。
if(size==data.length/2){
resize(data.length/2);
}
123注意
resize()方法設為私有，是為了用戶只需使用這個數組類，不必去顧慮數組的大小。
通過對addLast(T[] e)和removeLast(T[] e)時間復雜度的分析，我們發現都是O(n)級別的。但是，這樣一般性地考慮最壞的情況在這種情景下是沒有太大意義的。因為addLast(T[] e)和removeLast(T[] e)操作并不會經常觸發resize(int newCapcity)操作。所以用均攤復雜度分析的話，你會發現這兩個操作的均攤復雜度都是O(1)。因此resize(int newCapcity)這樣一個比較耗時的操作，如果保證不會每次都會觸發，就可以將它的操作耗時分攤到其他操作上。
現在再考慮另外一個場景，就是在addLast(T[] e)操作后，觸發了resize(int newCapcity)，然后再removeLast(T[] e)，又觸發了resize(int newCapcity)；如此循環。像這樣addLast(T[] e)和removeLast(T[] e)的時間復雜度都是O(n)級別的，這就是所謂的復雜度的震蕩。以數組這個例子，之所以發生這種情況是因為我們在removeLast操作后，就接著進行了resize操作這樣太著急了。那么該如何防止復雜度的震蕩呢？
可以這樣修改removeLast方法的代碼。
if(size==data.length/4 && data.length/4!=0){
resize(data.length/2);
}加上data.length/4!=0的判斷是因為當data.length/4==0的時候，數組長度變為0，這是不合法的。
public class Array<T> {
private T[] data;
private int size;
public Array() {
this(10);
}
public Array(int capacity) {
//java本身不支持直接new 一個泛型數組，所以用以下方法實現
data = (T[])new Object[capacity];
size = 0;
}
public int getSize() {
return size;
}
public int getCapacity() {
return data.length;
}
public boolean isEmpty() {
return size == 0;
}
/**
* 向數組末尾添加元素
*
* @param e
*/
public void addLast(T e) {
add(size, e);
}
/**
* 向數組開頭添加元素
*
* @param e
*/
public void addFirst(T e) {
add(0, e);
}
/**
* 向任意合法位置添加元素
*
* @param index
* @param e
*/
public void add(int index, T e) {
/*if (size == data.length) {
throw new IllegalArgumentException("Add is fail.Array is full");
}*/
if (index < 0 || index > size) {
throw new IllegalArgumentException("Add is fail.Require index >= 0 and index < size");
}
if(size == data.length){
resize(2*data.length);
}
for (int i = size; i > index; i--) {
data[i] = data[i - 1];
}
data[index] = e;
size++;
}
/**
* 獲取索引位置的元素
* 通過這種封裝，用戶無法查詢未使用的空間，保證了數據的安全性。
*
* @param index
* @return
*/
public T get(int index) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("Get is failed.Index is illegal");
}
return data[index];
}
/**
* 修改索引位置的元素
*
* @param index
* @param e
*/
public void set(int index, T e) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("Set is failed.Index is illegal");
}
data[index] = e;
}
/**
* 數組中是否包含某個元素
*
* @param e
* @return
*/
public boolean contains(T e) {
for (int i = 0; i < size; i++) {
//注意值的比較應修改為equals方法
if (data[i].equals(e)) {
return true;
}
}
return false;
}
/**
* 查詢數組中某個元素的索引
*
* @param e
* @return 沒有該元素則返回-1
*/
public int find(T e) {
for (int i = 0; i < size; i++) {
if (data[i].equals(e)) {
return i;
}
}
return -1;
}
/**
* 刪除index位置的元素，并且返回該元素
* 不用擔心刪除后原來size位置的元素，因為用無法訪問到它。
* 但是最好再寫一句data[size]=null 具體原因需要了解java的垃圾回收機制
*
* @param index
* @return
*/
public T remove(int index) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("Remove failed.Require index >=0 and index < size");
}
T ret = data[index];
for (int i = index; i < size - 1; i++) {
data[i] = data[i + 1];
}
//注意維護size
size--;
data[size]=null;
if(size==data.length/4 && data.length/4!=0){
resize(data.length/2);
}
return ret;
}
/**
* 不用擔心數組為空的情況，因為數組如果為空,remove方法就會拋出異常
* @return
*/
public T removeFirst(){
return remove(0);
}
public T removeLast(){
return remove(size-1);
}
/**
* 從數組中刪除元素e
* @param e
*/
public boolean removeElement(T e){
int index=find(e);
if(index!=-1){
remove(index);
return true;
}else{
return false;
}
}
/**
* 重寫toString()方法
*
* @return
*/
@Override
public String toString() {
StringBuilder res = new StringBuilder();
res.append(String.format("size= %d,capacity= %d\n", size, data.length));
res.append("[");
for (int i = 0; i < size; i++) {
res.append(data[i]);
if (i != size - 1) {
res.append(",");
}
}
res.append("]");
return res.toString();
}
private void resize(int newCapacity){
T[] newData=(T[])new Object[newCapacity];
for(int i=0;i<size;i++){
newData[i]=data[i];
}
data=newData;
}
}
到此，關于“JAVA中int類型數組怎么修改為泛型”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
