Java学习之路-(数组，集合)

数组

• 数组就是存储数据且长度固定的容器，数据的数据类型要一致

// 格式一：存储数据类型[] 数组名称 = new 存储数据类型[长度]
int[] arr = new int[3];

// 格式二：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
int[] arr = new int[]{1,2,3,4,5};

// 格式三：最常用的
int[] arr = {1,2,3,4,5};


// 数组的遍历：我们通过索引来访问数组
public static void main(String[] args) {
	int[] arr = {1,2,3,4,5};
	for (i=0; i<arr.length; i++) {
		System.out.println(arr[i])
	}
}

集合与泛型

1.集合可以装不同类型的元素，必须是引用类型，长度可变

• 集合常用的方法

boolean add(E e)  // 在集合末尾添加元素
boolean remove(Object o)  // 寻找集合中值与O的值相等的元素，并删除，最后返回true
void clear()  // 清除所有元素
boolean isEmpty()  // 判断集合是否为空
int size()  // 返回集合元素的个数
boolean addAll(Collection c)  // 将集合c的元素添加
Object[] toArray()  // 返回一个包含本集合中所有元素的数组，数组类型为，Object[]
Iterator iterator()  // 迭代器，遍历集合专用

• List中常用的接口

import java.util.*

// ArrayList：列表：查询快，操作慢
public class TestList {
	public static void main(String[] args) {
		List<String> demo = new ArrayList<>();
		demo.add("a");
		demo.add("b");
		demo.add(0, "c");
		demo.remove(2);  // 根据索引，返回被移除的元素
		demo.set(1, "A");  // 根据索引替换元素, 返回被移除的元素
		// 使用迭代器
		Iterator it = demo.iterator();
		while (it.hasNext()) {
			E i = it.next();
			System.out.println(i);
		}
		// 增强for循环
		for (E e : demo) {
			System.out.println(e);
		}
	}
}

// LinkedList:链表，操作快，查询慢
public class TestLinkedList {
	public static void main(String[] args) {
		LinkedList<String> demo = new LinkedList<>();
		demo.add("a");
		demo.add("b");
		demo.add("c");
		demo.addFirst("head"); // 等于push方法  demo.push("");
		demo.getFirst();
		demo.getLast();
		demo.removeFisrt();	// 会返回被移除的元素
		demo.removeLast();
		demo.pop();
		demo.clear(); 
	}
}

• Set集合

/*
	hashSet集合：
	无序不重复的集合
	因为无序，所以不能使用普通的for循环遍历
	hashSet 不重复的原理：
		执行add操作的时候，先对元素执行hashCode()方法，判断两个元素哈希值是否存在，不存在则添加
		如果哈希值已存在，则会执行equals方法，判定两个元素的值是否相同，如果相同，则不添加，如果不相同则添加
*/
public class TestSet {
	public static void main(String[] args) {
		Set<Integer> demo = new HashSet<>();
		demo.add(1)
		demo.add(2)
		demo.add(3)
		demo.add(1)
		// 使用迭代器可以遍历
		Iterator it = demo.iterator();
		while(it.hasNext()){
			int i = it.next();
			System.out.println(i);
		}
		// 使用增强for循环
		for (int i : demo) {
			System.out.println(i);
		}
	}
}

/*
LinkedHashSet():  有序不重复的集合。
	数据结构： 哈希表 + 数组/红黑树 + 链表
*/

• map集合

/*
	键值对
*/
public class TestMap {
	public static void main(String[] args) {
		test01();
	}
	public static void test01() {
		Map<String, String> demo = new HashMap<>();
		demo.put("a", "aaaa");	// 如果key不存在，返回value为null，如果key重复，会返回新的value
		demo.put("b", "bbbb");
		demo.put("c", "cccc");
		demo.put("d", "ddd");
		demo.put("e", "eeee");
		demo.put("f", "ffff");
		
		demo.remove("a");  // 返回被删除元素的value

		demo.get("b");  // 返回对应的value，如果key不存在，返回null
		
		demo.containsKey("c");  // 返回boolean值

		// map的遍历
		Set<String> set = demo.keySet();  // 将map中所有的key取出来，存储到set中
		for (String s : demo) {
			System.out.println(demo.get(s));
		}
	}
}

/*
	Entry对象：键值对对象，相当于python中每个字典的item
*/
public static void entryTest(Map demo) {
	Set<Map.Entry<String, String>> entry =  demo.entrySet(); // 获取每一个键值对，存在集合中
	// 遍历
	for (Map.Entry item: entry) {
		String key = item.getKey(); // 获取每个键值
		String value = item.getValue(); // 获取每个值	
	}
}

/*
通过HashMap存储自定义类型的键值
*/
public static void test() {
	HashMap<String, Person> demo = new HashMap<>();
	demo.put("a", new Person("aaa", 18));
	demo.put("b", new Person("bbb", 19));
	demo.put("c", new Person("ccc", 20));

	// 遍历
	Set<Map.Entry> entry = demo.entrySet();
	for (Map.Entry item, entry) {
		Person value = item.getValue();
		String key = item.getKey();
	}
}

/*
LinkedHashMap 集合，是一个有序的字典
数据结构：
	哈希表 + 链表
*/

/*
HashTable 集合：不允许有null做为key或者value，线程安全的
*/

2. 泛型
定义：当不明确数据类型的时候，应用泛型，可以看作用一个变量来接收数据类型，通常用E(element)来表示泛型

/*
使用泛型创建集合对象
	好处：
		1.避免类型转换的麻烦,取出的类型可以直接使用类型的特定的方法
		2.把运行期异常提升到编译期
	弊端：
		泛型是什么类型，只能存储什么类型的数据
*/ 
public static void main(String[] args) {
	ArrayList<String> demo =  new ArrayList<>();
	demo.add("abv");
	demo.add(1);  // 报错
	Iterator it = demo.iterator();
	while(it.hasNext) {
		String s = it.next();
		// 可以使用String类型的方法	
	}
}

/*
	定义一个含有泛型的类,并调用
*/
pulic class GenericClass<E> {
	private E name;
	public E getName() {
		return name;
	}
	public void setName(E name) {
		this.name = name;
	}
}


public static void main(String[] args) {
	GenericClass<String> demo1 = new GenericClass<>();
	demo1.setName("只能是字符串");
	
	GenericClass<Integer> demo2 = new GenericClass<>();
	demo1.setName(1);  // 只能是Integer类型
}


/*
	定义含有泛型的方法
	格式：
		修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)) {}
*/
public <E> void method1(E e) {
	System.out.println(e);
}

method1("a");
method1(1);
method1(1.1);
method1(true);

/*
	定义一个泛型的接口,并实现接口
*/
public interface GenericInterface<I> {
	public abstract void method(I i);
}

// 第一种实现方法：在创建实现类的时候就确定数据类型
public class GenericInterfaceImpl implements GenericInterface<自定义数据类型>{
	@override
	public void method(自定义数据类型 var) {
		System.out.println(var)
	}
}

//第二种实现方法：在创建对象的时候确定数据类型
public class GenericInterfaceImpl2 implements GenericInterface<I> {
	@override
	public void method(I i) {
		System.out.println(i);
	}
}

psvm{
	GenericInterfaceImpl2<String> demo = new GenericInterfaceImp2<>();
	demo.method("只能是字符串");
}

/*
	泛型通配符
		?:代表任意的数据类型
	使用方式：
		不能创建对象使用
		只能作为方法的参数使用
*/
public static void printArray(ArrayList<?> list) {
	Iterator it = list.iterator();
	while(it.hasNext) {
		object obj = it.next();
		System.out.println(obj);
	}
}

• 泛型的高级使用

/*
	泛型的上限限定： ? extends E	代表使用的泛型只能是E类型的子类/本身
	泛型的下限限定： ? super E	代表使用的泛型只能是E类型的父类/本身
*/
public static void getElement1(Collection<? extends Number> coll){}
public static void getElement2(Collection<? super Number> coll){}