java定義arraylist

❶ java 中ArrayList的用法！

1、如何使用ArrayList
最簡單的例子：
ArrayList List = new ArrayList();
for( int i=0;i <10;i++ ) //給數組增加10個Int元素
List.Add(i);
//..程序做一些處理
List.RemoveAt(5);//將第6個元素移除
for( int i=0;i <3;i++ ) //再增加3個元素
List.Add(i+20);
Int32[] values = (Int32[])List.ToArray(typeof(Int32));//返回ArrayList包含的數組

這是一個簡單的例子，雖然沒有包含ArrayList所有的方法，但是可以反映出ArrayList最常用的用法

2、ArrayList重要的方法和屬性
1）構造器
ArrayList提供了三個構造器：
public ArrayList();
默認的構造器，將會以默認（16）的大小來初始化內部的數組
public ArrayList(ICollection);
用一個ICollection對象來構造，並將該集合的元素添加到ArrayList
public ArrayList(int);
用指定的大小來初始化內部的數組

2）IsSynchronized屬性和ArrayList.Synchronized方法
IsSynchronized屬性指示當前的ArrayList實例是否支持線程同步，而ArrayList.Synchronized靜態方法則會返回一個ArrayList的線程同步的封裝。
如果使用非線程同步的實例，那麼在多線程訪問的時候，需要自己手動調用lock來保持線程同步，例如：
ArrayList list = new ArrayList();
//...
lock( list.SyncRoot ) //當ArrayList為非線程包裝的時候，SyncRoot屬性其實就是它自己，但是為了滿足ICollection的SyncRoot定義，這里還是使用SyncRoot來保持源代碼的規范性
{
list.Add( 「Add a Item」 );
}

如果使用ArrayList.Synchronized方法返回的實例，那麼就不用考慮線程同步的問題，這個實例本身就是線程安全的，實際上
ArrayList內部實現了一個保證線程同步的內部類，ArrayList.Synchronized返回的就是這個類的實例，它裡面的每個屬性都是用
了lock關鍵字來保證線程同步。

3）Count屬性和Capacity屬性
Count屬性是目前ArrayList包含的元素的數量，這個屬性是只讀的。
Capacity屬性是目前ArrayList能夠包含的最大數量，可以手動的設置這個屬性，但是當設置為小於Count值的時候會引發一個異常。

4）Add、AddRange、Remove、RemoveAt、RemoveRange、Insert、InsertRange
這幾個方法比較類似
Add方法用於添加一個元素到當前列表的末尾
AddRange方法用於添加一批元素到當前列表的末尾
Remove方法用於刪除一個元素，通過元素本身的引用來刪除
RemoveAt方法用於刪除一個元素，通過索引值來刪除
RemoveRange用於刪除一批元素，通過指定開始的索引和刪除的數量來刪除
Insert用於添加一個元素到指定位置，列表後面的元素依次往後移動
InsertRange用於從指定位置開始添加一批元素，列表後面的元素依次往後移動

另外，還有幾個類似的方法：
Clear方法用於清除現有所有的元素
Contains方法用來查找某個對象在不在列表之中

其他的我就不一一累贅了，大家可以查看MSDN，上面講的更仔細
5）TrimSize方法
這個方法用於將ArrayList固定到實際元素的大小，當動態數組元素確定不在添加的時候，可以調用這個方法來釋放空餘的內存。
6）ToArray方法
這個方法把ArrayList的元素Copy到一個新的數組中。
3、ArrayList與數組轉換
例1：
ArrayList List = new ArrayList();
List.Add(1);
List.Add(2);
List.Add(3);

Int32[] values = (Int32[])List.ToArray(typeof(Int32));

例2：
ArrayList List = new ArrayList();
List.Add(1);
List.Add(2);
List.Add(3);

Int32[] values = new Int32[List.Count];
List.CopyTo(values);

上面介紹了兩種從ArrayList轉換到數組的方法

例3：
ArrayList List = new ArrayList();
List.Add( 「string」 );
List.Add( 1 );
//往數組中添加不同類型的元素

object[] values = List.ToArray(typeof(object)); //正確
string[] values = (string[])List.ToArray(typeof(string)); //錯誤

和數組不一樣，因為可以轉換為Object數組，所以往ArrayList裡面添加不同類型的元素是不會出錯的，但是當調用ArrayList方法的時候，要麼傳遞所有元素都可以正確轉型的類型或者Object類型，否則將會拋出無法轉型的異常。

❷ java中Arraylist是干什麼的怎麼用

java中的ArrayList就是傳說中的動態數組，用MSDN中的說法，就是Array的復雜版本。

它提供了如下一些好處：動態的增加和減少元素實現了ICollection和IList介面靈活的設置數組的大小 。

ArrayList 的用法：

ArrayList List = new ArrayList(); for( int
i=0;i<10;i++ ) //

給數組增加10個Int元素 List.Add(i); //..

程序做一些處理
List.RemoveAt(5);//

將第6個元素移除 for( int i=0;i<3;i++ ) //

再增加3個元素
List.Add(i+20); Int32[] values =
(Int32[])List.ToArray(typeof(Int32));//

返回ArrayList包含的數組 。

(2)java定義arraylist擴展閱讀：

Arraylist的定義：

List 介面的大小可變數組的實現，位於API文檔的java.util.ArrayList<E>。

實現了所有可選列表操作，並允許包括 null 在內的所有元素。

除了實現 List 介面外，此類還提供一些方法來操作內部用來存儲列表的數組的大小。（此類大致上等同於 Vector 類，除了此類是不同步的。）

size、isEmpty、get、set、iterator 和 listIterator 操作都以固定時間運行。

add 操作以分攤的固定時間 運行，也就是說，添加 n 個元素需要 O(n) 時間。

其他所有操作都以線性時間運行（大體上講）。

與用於 LinkedList 實現的常數因子相比，此實現的常數因子較低。

每個 ArrayList 實例都有一個容量。該容量是指用來存儲列表元素的數組的大小。

它總是至少等於列表的大小。隨著向 ArrayList 中不斷添加元素，其容量也自動增長。

並未指定增長策略的細節，因為這不只是添加元素會帶來分攤固定時間開銷那樣簡單

在添加大量元素前，應用程序可以使用
ensureCapacity 操作來增加 ArrayList
實例的容量。這可以減少遞增式再分配的數量。

注意，此實現不是同步的。如果多個線程同時訪問一個 ArrayList
實例，而其中至少一個線程從結構上修改了列表，那麼它必須 保持外部同步。

（結構上的修改是指任何添加或刪除一個或多個元素的操作，或者顯式調整底層數組的大小；僅僅設置元素的值不是結構上的修改。）

這一般通過對自然封裝該列表的對象進行同步操作來完成。

如果不存在這樣的對象，則應該使用 Collections.synchronizedList 方法將該列表「包裝」起來。這最好在創建時完成，以防止意外對列表進行不同步的訪問：

List list = Collections.synchronizedList(new ArrayList(...));

此類的 iterator 和 listIterator 方法返回的迭代器是快速失敗的。

在創建迭代器之後，除非通過迭代器自身的
remove 方法從結構上對列表進行修改，否則在任何時間以任何方式對列表進行修改，迭代器都會拋出
。

因此，面對並發的修改，迭代器很快就會完全失敗，而不是冒著在將來某個不確定時間發生任意不確定行為的風險。

注意，迭代器的快速失敗行為無法得到保證。

因為一般來說，不可能對是否出現不同步並發修改做出任何硬性保證。快速失敗迭代器會盡最大努力拋出

。

因此，為提高這類迭代器的正確性而編寫一個依賴於此異常的程序是錯誤的做法：迭代器的快速失敗行為應該僅用於檢測
bug。

❸ java如何動態創建ArrayList並給其賦值

1、ArrayList是動態數組，List是一個介面，不能實例化，需要實例化一個ArrayList；

List list = new ArrayList();
2、使用list .add(任何對象);就可以進行添加了。代碼如下：

bean類
package com.whn.bean;

public class ListBean {
private String name;
private String pwd;

public void setName(String name) {
this.name = name;
}

public String getName() {
return name;
}

public void setPwd(String pwd) {
this.pwd = pwd;
}

public String getPwd() {
return pwd;
}
}

測試類package com.whn.test;

import com.whn.bean.ListBean;

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

public class ListTest {
//測試
public static void main(String[] args) {
List<ListBean> list = new ArrayList<ListBean>();//實例化一個arrayList
//添加
for(int i=10;i<20;i++){
ListBean listBean = new ListBean();
listBean.setName("name"+i);
listBean.setPwd("pwd"+i);
list.add(listBean);//把listBean添加到arrayList中
}

//把數據取出來
for(ListBean lb:list){
System.out.println(lb.getName());
System.out.println(lb.getPwd());
}

}
}

❹ java arraylist 用法

如果輸出的全是整型的話可以使用下面這種方式

ArrayList<Integer>List=newArrayList<Integer>();
Integer[]num=newInteger[List.size()];
List.toArray(num);

如果輸出的不確定那就得循環List一個一個給數組賦值了

❺ 安卓 JAVA定義Arraylist的一點小問題。求解決。

static ArrayList<BOOK> list = new ArrayList<BOOK>(); 把list 改成全局的
調用的時候直接類名.list 調用 這樣你添加的地方 和取的地方才是同一個list

你前面那種做法 /這是另一個類實現增加功能，調用addBook方法往數組裡面加了值。 增加的功能 new 了一個fangfa 調用list 添加了書籍

後面查詢的時候 又new 了一個fangfa 這是2個對象不同的list

我猜你現在的情況是這樣的

class fangfa {

ArrayList<BOOK> list = new ArrayList<BOOK>();

public fangfa() {
jia();
}

public void jia() {

}

public ArrayList<BOOK> getList() {
return list;
}

public void setList(ArrayList<BOOK> list) {
this.list = list;
}

public Boolean addBOOK(BOOK b) {

String id = b.getId();
for (int i = 0; i < list.size(); i++) {
BOOK book = list.get(i);
String id1 = book.getId();
if (id.equals(id1)) {
return false;
}
}
list.add(b);
return true;
}
}

class BOOK {

private String id;
private String name;
private String price;

public BOOK(String id, String name, String price) {
this.id = id;
this.name = name;
this.price = price;
}

public String getId() {
return id;
}

public void setId(String id) {
this.id = id;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getPrice() {
return price;
}

public void setPrice(String price) {
this.price = price;
}
}

class addClass{
public void add(){
fangfa ff = new fangfa();
BOOK b = new BOOK("1","水滸","29");
ff.addBOOK(b);
}
}

public class Test{
public static void main(String args[]){
addClass ac = new addClass();
ac.add();
fangfa ff = new fangfa();
List<BOOK> list = ff.getList();

for(BOOK book:list){
System.out.println(book.getName());
}
}
}

static ArrayList<BOOK> list = new ArrayList<BOOK>(); 加上static 就可以得到了， 你可以自己試驗一下

❻ Java ArrayList的使用

importjava.util.*;
classStudent{//定義學生類
	Stringname;
	Student(Stringname){//構造方法
		this.name=name;
	}
	//重寫equals方法，保證只要名字相等，則認為是同一個人.
	publicbooleanequals(Objectobj){
		if(name==null||obj==null){
			returnfalse;
		}
		if(objinstanceofStudent){
			Studentsd=(Student)obj;
			returnname.equals(sd.name);
		}
		returnfalse;
	}
}
publicclasst2{
	publicstaticvoidmain(String[]args){
		Scannerreader=newScanner(System.in);
		Student[]stu=newStudent[4];//定義
		ArrayList<Student>stus=newArrayList<Student>();//ArrayList泛型，每個元素是1個學生。								
		System.out.println("輸入4個學生姓名：");
		//初始化4個學生，並將他們添加進ArrayList
		for(inti=0;i<4;i++){
			stu[i]=newStudent(reader.nextLine());
			stus.add(stu[i]);
		}
		System.out.println("列表中還有"+stus.size()+"個學生：");
		for(inti=0;i<stus.size();i++){//遍歷輸出所有元素中學生的姓名
			System.out.println("第"+i+"個學生:"+stus.get(i).name);
		}
		//鍵盤輸入一個學生姓名,判斷該學生是否在列表中，如存在，則輸出其在列表中的下標，然後將它從列表中移除。
		System.out.println("輸入要查找的人的姓名：");
		Students=newStudent(reader.nextLine());
		if(stus.contains(s)){
			System.out.println("找到"+s.name+"，下標為"+stus.indexOf(s));//輸出下標
			stus.remove(s);//從列表中移除該學生
			System.out.println("刪除"+s.name+"後,還有"+stus.size()+"個學生：");
			for(inti=0;i<stus.size();i++){//遍歷輸出所有元素中學生的姓名
				System.out.println("第"+i+"個學生:"+stus.get(i).name);
			}
		}else
			System.out.println("列表中找不到"+s.name);//如不存在則輸出找不到。
	}
}

效果

輸入4個學生姓名：
天涯
明月
秋水
清泉
列表中還有4個學生：
第0個學生:天涯
第1個學生:明月
第2個學生:秋水
第3個學生:清泉
輸入要查找的人的姓名：
天涯
找到天涯，下標為0
刪除天涯後,還有3個學生：
第0個學生:明月
第1個學生:秋水
第2個學生:清泉

❼ 在java中如何定義一個字元串數組

1. java中定義一個字元串數組方式如下，string類型和其他基本類型相似，創建數組有兩種方式：
String[] str={"AAA","BBB","CCC"};
String str[]={"AAA","BBB","CCC"};

2.推薦用ArrayList<String> strArray = new ArrayList<String> (); 比較靈活。

3.也可以寫為如下格式：class[] array; array = new class[number];其中前半句為聲明，後半句為初始化，初始化必須要讓編譯器知道大小，聲明的時候java是不分配內存的，只有創建的時候也就是new的時候才會分配內存。

(7)java定義arraylist擴展閱讀：

1.數組是相同數據類型的元素的集合。

2.數組中的各元素的存儲是有先後順序的，它們在內存中按照這個先後順序連續存放在一起。

3.數組元素用整個數組的名字和它自己在數組中的順序位置來表示。例如，a[0]表示名字為a的數組中的第一個元素，a[1]代表數組a的第二個元素，以此類推。

4.對於VB的數組，表示數組元素時應注意：下標要緊跟在數組名後，而且用圓括弧括起來（不能用其他括弧）。下標可以是常量，變數，或表達式，但其值必須是整數。下標必須為一段連續的整數，其最小值成為下界，其最大值成為上界。不加說明時下界值默認為1。