简单认识动态数组 -

VIP庚

浏览: 221123 次
性别:
来自: 杭州

最近访客更多访客>>

tansh63

xubbsun

yongbiyanqi

吾乃隔壁老王

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

简单认识动态数组

java 框架

什么是数组？
数组是具有相同的数据类型且按一定次序排列的一组变量的集合体

一维数组：连续内存的，线性的，有下标的，长度固定的
动态数组: 连续内存的，线性的，有下标的，长度可变的

说到动态数组那么不如自己定义一个

public class DynamicArray2<E> {

	int rongliang = 10;// 容量
	int bilv = 10;// 增长比率
    Object[] src = new Object[rongliang];

	public DynamicArray2(){
		
	}
	
	public DynamicArray2(int rongliang, int bilv) {
		this.rongliang = rongliang;
		this.bilv = bilv;
		Object[] src = new Object[rongliang];
	}

	// 三个新概念
	// 容量，增长比率，可变数组长度（元素个数）

	// 定义一个原始数组
	

	/**
	 * 查找数组中第一个为null的位置下标
	 * 
	 * @return
	 */
	private int getNullIndex() {
		for (int i = 0; i < src.length; i++) {
			if (src[i] == null) {
				return i;
			}
		}
		return -1;
	}

	/**
	 * 将指定元素放入数组
	 * 
	 * @param s
	 *            要放入的元素内容
	 */
	public void add(E s) {
		// 如果长度<容量，不需要新数组
		if (size() >= src.length) {
			// 定义一个新数组，长度是原始数组长度+1
			Object[] dest = new Object[src.length + bilv];
			// 将原始数组中的数据考入新数组
			for (int i = 0; i < src.length; i++) {
				dest[i] = src[i];
			}

			// 将src指向新数组
			src = dest;
		}

		int index = getNullIndex();
		src[index] = s;

	}

	/**
	 * 根据下标取出元素
	 * 
	 * @param index
	 *            要取出的元素的下标
	 * @return 返回取得的元素
	 */
	public E get(int index) {
		if (index < 0 || index >= size()) {
			throw new RuntimeException("给定的index超出范围:size:" + size()
					+ ",index:" + index);
		}

		E s = (E)src[index];
		return s;
	}

	/**
	 * 获得数组中的元素个数 返回数组中连续的不为null的元素个数
	 * 
	 * @return 返回获得的元素个数
	 */
	public int size() {
		int count = 0;
		for (int i = 0; i < src.length; i++) {
			if (src[i] != null) {
				count++;
			} else {
				break;
			}

		}

		return count;
	}

	/**
	 * 将指定的元素放入指定的位置
	 * 
	 * @param s
	 *            要放入的元素
	 * @param index
	 *            元素所在的位置
	 */
	public void insert(E s, int index) {
		if (size() >= src.length) {
			// 定义一个新数组，长度是原始数组长度+1
			Object[] dest = new Object[src.length + bilv];
			// 将原始数组中的数据考入新数组
			for (int i = 0; i < src.length; i++) {
				dest[i] = src[i];
			}

			// 将src指向新数组
			src = dest;
		}
		for(int i=size();i>index;i--){
			src[i]=src[i-1];
		}
		src[index]=s;
		
	}

	/**
	 * 修改指定位置的元素
	 * 
	 * @param s
	 *            修改后的新元素
	 * @param index
	 *            元素的位置
	 */
	public void modify(E s, int index) {
		src[index] = s;
	}

	/**
	 * 删除指定位置的元素
	 * 
	 * @param index
	 *            要删除的元素的位置
	 * @return 返回被删除的元素
	 */
	public E delete(int index) {
		E e = (E)src[index];
		for(int i=index;i<size();i++){
			src[i] =src[i+1]; 
		}
		
		return e;
	}

	/**
	 * 删除指定的元素
	 * 
	 * @param s
	 *            要删除的元素
	 */
	public void delete(E s) {
		int index = -1;
		for (int i = 0; i < src.length; i++) {
			if (src[i].equals(s)) {
				index = i;
				break;
			}
		}

		delete(index);
	}

}

在java 中已经为我们定义了集合框架（接口）   Collection
Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。

Set    不允许重复元素的一组数据集合   无下标   无序
        HashSet    TreeSet
List   允许重复元素   带下标有序
        ArrayList

HashSet:
此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。

将数据放入HashSet中

public static void hashSetDemo() {
		// 创建集合对象
		HashSet<String> set = new HashSet<String>();

		// 放入元素
		for (int i = 0; i < 10; i++) {
			String s = "张三" + i;
			set.add(s);
		}

		set.add("李四");
		boolean b = set.add("李四");
		System.out.println(b);

		boolean b2 = set.contains("李四");
		System.out.println(b2);

		// 取出元素，使用迭代器
		// Iterator<String> iter = set.iterator();
		// while(iter.hasNext()){
		// //取出并移除元素
		// String s = iter.next();
		// System.out.println(s);
		// }

		// 取出元素，使用增强for循环
		for (String s : set) {
			System.out.println(s);
		}

	}

对于set集合取出集合中的元素有两种方法

方法一通过获得迭代器的方法

Set接口中 public Iterator<E> iterator() 函数
返回对此 set 中元素进行迭代的迭代器。返回元素的顺序并不是特定的
再通过 Iterator类中的 E next() 返回迭代的下一个元素

Iterator<String> iter = set.iterator();
 while(iter.hasNext()){
	//取出并移除元素
         String s = iter.next();
        System.out.println(s);
 }

注：1 迭代器中每取出一个元素都会将元素移除迭代器但对Set集合没哟影响
2 Iterator类中hasNext(）函数如果仍有元素可以迭代，则返回 true

方法二：用使用增强for循环来取出元素

for (String s : set) {
			System.out.println(s);
		}

TreeSet：

public static void treeSetDemo(){
		//创建TreeSet对象
		TreeSet<Integer> set = new TreeSet<Integer>();
		
		set.add(100);
		set.add(80);
		set.add(110);
		set.add(120);
		set.add(119);
		set.add(1);
		
		Integer tt = new Integer(111);
		set.add(tt);
		
		Integer tt1 = new Integer(111);
		set.add(tt1);
		
//		返回此 set 中所包含元素的逆序视图
		NavigableSet<Integer> nset = set.descendingSet();
		
		for(int t:nset){
			System.out.println(t);
		}
		
		//获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。
//		while(!set.isEmpty()){
//			int t = set.pollLast();
//			System.out.println(t);
//		}
		
	}

接口 Map<K,V> 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

键：是一个set，不重复，无下标无序
值：每个键对应一个值，可重复

一个键只能对应一个值
一个值只能指向一个键

public static void main(String[] args) {
		//映射存储学号和姓名
		HashMap<Integer,String> map = new HashMap<Integer,String>();
		
		//放入数据
		map.put(123, "张三疯");
		map.put(124, "郭靖");
		map.put(125, "张无忌");
		map.put(126, "张翠山");
		
		//如果key重复，则会替换key对应的value
		map.put(126, "苗翠花");
		map.put(126, "翠花");
		
		/*
		//取出数据：根基EntrySet
		Set<Map.Entry<Integer, String>> set = map.entrySet();
		
		//Map.Entry：一个键值对就是一个Entry对象
		for(Map.Entry<Integer, String> entry:set){
			
			int key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key+">>>"+value);
			
		}
		*/
		
		
		//遍历方式二：根据KeySet
		Set<Integer> set = map.keySet();
		for(int key:set){
			String value = map.get(key);
			System.out.println(key+">>>"+value);
		}
		
	}

注：
1 HashMap中如果key重复，则会替换key对应的value
2 Map取元素有两种方法
    方法一：
    通过Map中Set<Map.Entry<K,V>> entrySet()方法返回此映射中包含的映射关系的 Set 视图   再通过Set得到Map.Entry对象    K getKey() 返回与此项对应的键。 V getValue() 返回与此项对应的值。

    方法二：
    根据KeySet 返回此映射中包含的键的 Set 视图
    再通过   V get(Object key) 返回指定键所映射的值

练习:给定任意字符串，统计该字符串中每个字符出现的次数
String s="abbcccddddeeeee";

public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		String str = "abbcccddddeeeee";
		TreeMap<Character,Integer> map = new TreeMap<Character,Integer>();
		for(int i=0;i<str.length();i++){
			if(map.containsKey(str.charAt(i))){
				int b = map.get(str.charAt(i));
				map.put(str.charAt(i), ++b);
			}else{
				map.put(str.charAt(i), 1);
			}
		}
		//通过entrySet得到映射关系映射关系
//		Set<Entry<Character, Integer>> set=map.entrySet();
//		for(Entry<Character, Integer> q:set){
//			System.out.println(q.getKey()+"  "+q.getValue());
//		}
		
		
		//通过keySet包含的键的 Set   再通过键  得到 键所对应值
		Set<Character> t = map.keySet();
		for(char b:t){
			System.out.println(b+" "+map.get(b));
		}
		//迭代器循环取出元素
//      Iterator ter = tree.iterator();
//		
//		while(ter.hasNext()){
//			System.out.println(ter.next());
//		}
		
	}

分享到：