java基础-集合框架

一 数据类型转换

package com.great.demo;

public class Test {

	/*
	 * 基本数据类型的类型转换：
	 * 1.直接转换(当位数低将数据赋值给位数高的类型时，直接转换即可)
	 * 2.强制类型转换 (当位数高将数据赋值给位数低的类型时，就需要强制类型转换)
	 * 
	 * 复合引用数据类型的类型转换：
	 * 1.直接转换(当初始化子类时，可以将子类的地址赋值给父类)
	 * 2.强制类型转换
	 * 注意：复合引用类型的强制类型转换，不能直接正常初始化父类
	 * 复合引用数据类型的强制类型转换需要：
	 * 1.需要子类来初始化父类对象（多态）
	 * 2.结构：
	 * 子类类名  子类变量名 = (子类类名)父类变量名;
	 * Penguin p1 = (Penguin) anim1;
	 * 
	 * 
	 * 
	 * 
	 */
	
	
	public static void main(String[] args) {
		
		int a = 10;
		float b = a;
		
		float b1 = 3.14f;
		int a1 = (int) b1;
		
		
		Penguin p = new Penguin();
		Animal anim = p;
		System.out.println(anim);
		
		
		Animal anim1 = new Penguin();
		Animal anim2 = new Bear();
		/*anim1.*/
		Penguin p1 = (Penguin) anim1;
		//注意：如果是熊类初始化父类对象，如果需要强制类型转换也是将父类转换成熊的对象，无法转换成其企鹅对象
		Penguin p2 = (Penguin) anim2; 
		
		System.out.println(p1);
	}
	
}

二 Arraylist

package com.great.demo1;

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

public class Demo {

	/*
	 * 什么时候用到数组：
	 * 当数据类型，数据量确定就用到数组
	 * 
	 * 什么时候利用到集合框架：
	 * 当数据类型确定，数据量不确定就用到集合框架
	 * 
	 * 泛型：广泛的类型
	 * 泛型的书写格式：<复合引用数据类型>
	 * 
	 * 1.ArrayList(数组列表):
	 * 初始化：
	 * 方法1
	 * ArrayList<复合引用数据类型> 变量名 = new ArrayList<复合引用数据类型>();
	 * 方法2
	 * List<复合引用数据类型> 变量名 = new ArrayList<复合引用数据类型>();
	 * //初始化一个存放整型类型数据的集合框架，变量名叫arr
	 * ArrayList<Integer> arr = new ArrayList<Integer>();
	 * //用多态的方式书写
	 * List<Integer> list1 = new ArrayList<Integer>();
	 * 
	 * 常用方法：
	 * 1.add 添加
	 * 2.get 取出数据
	 * 3.arr1.remove(0);//当数据被移除时，后一位的数据都会往前进一位
	 * 
	 * 
	 */
	
	public static void main(String[] args) {
		//初始化一个存放整型类型数据的集合框架，变量名叫arr
		ArrayList<Integer> arr = new ArrayList<Integer>();
		//用多态的方式书写
		List<Integer> list1 = new ArrayList<Integer>();
		
		arr.add(new Integer(1));
		
		ArrayList<String> arr1 = new ArrayList<String>();
		arr1.add("Hello");
		arr1.add("World");
		
		System.out.println("NO.1:"+arr1.get(0));
		
		arr1.remove(0);//当数据被移除时，后一位的数据都会往前进一位
		System.out.println("NO.2:"+arr1.get(0));
		
		arr1.add(0, "刘彬"); //当数据插入选择位置时，之前的当前位置数据会往后移动一位
		System.out.println("NO.3:"+arr1.get(0));
		System.out.println("NO.4:"+arr1.get(1));
	
		System.out.println("NO.5:"+arr1.size()); //得到数据的数据长度
		
		arr1.clear();//清空整个集合框架中的数据
		System.out.println("NO.6:"+arr1.size()); 
		
		
		ArrayList<Person> list = new ArrayList<Person>();
		for (int i = 0; i < 5; i++) {
			Person person = new Person("LIUBIN"+i);
			list.add(person);
		}
		
		for (int i = 0; i < list.size(); i++) {
			Person p = list.get(i);
			System.out.println(p.getName());
		}
	}
}

package com.great.demo1;

public class ArrayDemo {

	private String[] arr;
	private int counts;
	
	public ArrayDemo(){
		arr = new String[10];
		counts = 0;
	}
	
	//添加数据的方法
	public void add(String msg){
		counts ++;
		//是否在正常情况下，也就是数组的内容是否已经满了？
		if(arr[arr.length-1] != null){ //当数组的最后一个位置的元素已经有值了，就证明数组已经满了
			String[] arrCopy = new String[arr.length*2]; //将当前的数组设置为之前数组长度的两倍
			//数组拷贝方法,参数：1.原数组，2.原数组拷贝的初始位置，3.目标数组对象，4.目标数组粘贴的初始位置，5.需要复制的长度
			System.arraycopy(arr, 0, arrCopy, 0, arr.length);
			arr = arrCopy;
		}
		
		//在正常情况下，直接进行赋值
		for(int i=0;i<arr.length;i++){
			if(arr[i] == null){
				arr[i] = msg;
				return;
			}
		}
	}
	
	//得到当前的数据数目
	public int getSize(){
		return counts;
	}
	
	//得到当前数组中index位置的数据
	public String get(int index){
		
		return arr[index];
	}
}

三 LinkedList

package com.great.demo2;

import java.util.LinkedList;

public class Demo {

	/*
	 * LinkedList适用于查询，更改，删除，添加
	 * 对于遍历来说，ArrayList效率比他高
	 * 
	 * 初始化
	 * LinkedList<String> list = new LinkedList<String>();
	 * 
	 * List<String> list = new LinkedList<String>();
	 * 
	 * 
	 */
	
	public static void main(String[] args) {
		
		LinkedList<String> list = new LinkedList<String>();
		/*list.addFirst(e); *///将数据添加在第一个位置，之前第一个位置数据开始往后移动一位
		for (int i = 0; i < 10; i++) {
			list.add("Hello"+i);
		}
		
	}
}

 

package com.great.demo2;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class Demo2 {

	/*
	 * Hashmap:
	 * K:key(钥匙):主要是为了寻找对应的值
	 * 条件：
	 * 1.钥匙要唯一
	 * 2.钥匙不能为空
	 * 3.必须是复合引用类型
	 * 
	 * V:value(值):
	 * 1.必须是复合引用类型
	 * 
	 * 
	 * 遍历方式：foreach
	 * String[] arr = {"zhangsan","lisi","wangwu"};
	 * for(String str:arr){ //将arr数组内部的每一个数组都赋值给String类型的变量str
			System.out.println(str);
		}
	 * 
	 * 初始化：
	 * 方式1：
	 * HashMap<Key, Value> 变量名 = new HashMap<Key, Value>();
	 * HashMap<Integer, User> map = new HashMap<Integer, User>();
	 * 方式2：
	 * Map<Key, Value> 变量名 = new HashMap<Key, Value>();
	 * Map<Integer, User> map = new HashMap<Integer, User>();
	 * 
	 * 常用方法：put //添加     get//取出   
	 * 
	 */
	public static void main(String[] args) {
		ArrayList<User> list = new ArrayList<User>();
		list.add(new User(1, "刘彬"));
		list.add(new User(2, "叶威"));
		list.add(new User(3, "成伟"));
		
		HashMap<Integer, User> map = new HashMap<Integer, User>();
		map.put(40, new User(40, "水哥"));
		map.put(1, new User(1, "刘彬"));
		map.put(2, new User(2, "叶威"));
		map.put(3, new User(3, "成伟"));
		map.put(3, new User(3, "佳泉")); //注意：如果key值相同，就会覆盖之前的value值,打印的是最后一个值
		
		User user = map.get(3);
		System.out.println(user.getName());
		
		/*map.remove(3);
		System.out.println(map.get(3));*/
		
		
		//遍历Hashmap
		Set<Integer> set = map.keySet(); //1.将map中的所有key放置到Set集合中
		for(Integer in:set){ //2.通过遍历将所有的key取出,既然key能取出，value也能取出来
			System.out.println(in +","+ map.get(in).getName());
		}
		//迭代器方式遍历HashMap
		Set<Integer> set1 = map.keySet();
		Iterator<Integer> it = set1.iterator(); //Iterator:迭代器
		while(it.hasNext()){ //查询是否有下一个值，返回boolean类型
			System.out.println("Iterator:"+it.next()); //得到内部的Integer类型的值
		}
		
		
		
		
		String[] arr = {"zhangsan","lisi","wangwu"};
		for(String str:arr){ //将arr数组内部的每一个数组都赋值给String类型的变量str
			System.out.println(str);
		}
		
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
		
		
		int[] arr1 = new int[5];
		for(int i:arr1){ //尽量不要用来赋值，不要用来初始化
			i = 10;
		}
		System.out.println(arr1[0]);
		
		
		
	}
	
}