Java集合数组分析

最新推荐文章于 2023-07-12 15:47:11 发布

一只会说话的兔子

最新推荐文章于 2023-07-12 15:47:11 发布

阅读量285

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.youkuaiyun.com/syp_snowy/article/details/73460091

版权

Note 同时被 2 个专栏收录

10 篇文章

订阅专栏

java

6 篇文章

订阅专栏

数组：连续的空间存储数据
好处：便于数据的修改和查看
坏处：不便数据的增加和删除，数组扩容

集合框架

出现的原因：满足不同的需求
好处：自动扩容

(一)Iterable（可迭代的）

1.Iterator(迭代器)

foreach(增强for循环)：用来遍历数组
语法：for（类型变量：集合）

2.Collection

list：添加和访问一致
set:添加和访问不一致（由于去重，元素唯一）

1.List：添加顺序和打印顺序一致。掌握方法：增删改查

package com.sxt.collection;

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

public class TextList {
public static void main(String[] args) {
	List list=new ArrayList();
	//添加
	list.add("asd");
	list.add("azx");
	list.add("shfuwie");
	print(list);
	System.out.println("----------------");
	//修改
	list.set(0, "syp");
	print(list);
	System.out.println("----------------------");
	//查询
	list.get(1);
	list.subList(0, 2);
	print(list);
	System.out.println("----------------------");
	//删除
	list.remove(0);
//	list.remove("asd");//删除一个对象,需重写equals方法
	print(list);
}

private static void print(List list) {
	System.out.println(list);
	
}
}

（1） ArrayList(线程不安全)
适用范围：频繁的查找

package com.sxt.collection;

public class StudentM {
private String name;
private int age;
public StudentM(String name, int age) {
	super();
	this.name = name;
	this.age = age;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public int getAge() {
	return age;
}
public void setAge(int age) {
	this.age = age;
}
@Override
public String toString() {
	return "姓名：" + name + ", 年龄：" + age ;
}
@Override
	public boolean equals(Object obj) {
		if(obj==null) return false;
		if(obj instanceof StudentM){
			StudentM sm=(StudentM)obj;
			return toString().equals(sm.toString());
		}
		return false;
	}
}

package com.sxt.collection;

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

public class ArrayListM {
public static void main(String[] args) {
	List list=new ArrayList();//多态，父类引用指向子类对象
//	int i=0;
//	list.add(i);//自动封箱成Interger
	//向list集合中添加元素
	list.add(new StudentM("zhansan",10));
	list.add(new StudentM("lisi",9));
	list.add(new StudentM("zhangsan",12));
	list.add(1, new StudentM("wangwu", 11) );//根据index 添加数据
	print(list);
	System.out.println("以上添加----------------");
	//修改
	list.set(0, new StudentM("zs", 10));
	print(list);
	System.out.println("以上修改----------------------");
	//查询
//	list.get(1);
//	list.subList(0, 2);
	int selectCount=list.indexOf(new StudentM("lisi", 9));//根据字符串查索引
	System.out.println(selectCount);
	boolean b=list.contains(new StudentM("zhangsan", 12));//查询集合中是否包含该对象
	System.out.println(b);
//	list.containsAll(list);
	print(list);
	System.out.println("以上查询----------------------");
	//删除
	list.remove(new StudentM("wangwu", 11));//（remove）集合中一个对象,需重写equals方法
//	list.clear();//清除所有数据
//	list.remove(0);//根据索引删除
	print(list);
	System.out.println("以上删除----------------------");
	/**
	 * 迭代器遍历数组（增强for循环）
	 */
//	Iterator iterator=list.iterator();
//	while(iterator.hasNext()){
//		System.out.println(iterator.next());
//	}
}
/**
 * 数组的遍历
 * @param list
 */
private static void print(List list) {
	for(int i=0;i<list.size();i++){
		StudentM sm=(StudentM)list.get(i);
		System.out.println(sm);
	}
	
}
}

（2） LinkList（线程不安全）

2.Set：添加顺序和访问顺序不一致。增删查

package com.sxt.set_me;

import java.util.HashSet;

public class Student1 {
//	public class Student1 implements Comparable<Student1>{
	private String name;
	private int age;
	private boolean sex;
	public Student1(String name, int age, boolean sex) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public boolean isSex() {
		return sex;
	}
	public void setSex(boolean sex) {
		this.sex = sex;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "姓名："+name+",  年龄："+age+",  性别："+sex;
	}
//	@Override
//	public int compareTo(Student1 o) {
//		// TODO Auto-generated method stub
//		return toString().compareTo(o.toString());
//	}
	@Override
	public boolean equals(Object obj) {
		Student1 s=(Student1)obj;
		return s.toString().equals(this.toString());
	}
	@Override
	public int hashCode() {
		// TODO Auto-generated method stub
		return toString().hashCode();
	}
	}

好处：自动去重（需根据具体需求重写hashcode、equals），排序（默认升序）

（1）HashSet（底层hash表）

hash表=数组+链表（）。如果将数据存储到hash表中，必须要重写equals和hashcode方法

package com.sxt.set_me;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class TextHash1 {
public static void main(String[] args) {
	Set set=new HashSet<>();
	set.add(new Student1("张三",10,true));//true 男
	set.add(new Student1("张三",11,true));
	set.add(new Student1("李四",10,false));
	set.add(new Student1("李四",15,true));
	set.add(new Student1("张三",10,true));
	set.add(new Student1("李四",10,true));
	print(set);
}

private static void print(Set set) {
	Iterator iterator=set.iterator();
	while(iterator.hasNext()){
		System.out.println(iterator.next());
	}
}
}

（2）TreeSet（底层二叉树）

compareTo(去重)，还可以排序

package com.sxt.set_me;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class TextTree1 {
public static void main(String[] args) {
	Set set =new TreeSet<>(new Comparator<Student1>() {

		@Override
		public int compare(Student1 o1, Student1 o2) {
			// TODO Auto-generated method stub
//			//默认排序
//			return o1.toString().compareTo(o2.toString());
			//根据年龄排序
			int c= o1.getAge()-o2.getAge();
			if(c!=0){
				return c;
			}
			c=o1.getName().compareTo(o2.getName());
			if(c!=0){
				return c;
			}
			return new Boolean(o1.isSex()).compareTo(o2.isSex());
		}
	});
//	set.add("abc");
//	set.add("bac");
//	set.add("acd");
//	set.add("abc");
//	print(set);
	set.add(new Student1("张三",10,true));//true 男
	set.add(new Student1("张三",11,true));
	set.add(new Student1("李四",10,false));
	set.add(new Student1("李四",15,true));
	set.add(new Student1("张三",10,true));
	set.add(new Student1("李四",10,true));
//	set.clear();
//	set.remove();
	set.contains(set);	
	print(set);
}

private static void print(Set set) {
	Iterator iterater=set.iterator();
	while(iterater.hasNext()){
		System.out.println(iterater.next());
	}
	
}
}

(二)MAP(Key,Value)

代码中的使用

package com.sxt.lianxi.map;

import java.util.List;

public class GoodList {
private String name;
private int age;
private List<Goods> data;

static class Goods{
	
}
}

package com.sxt.lianxi.map;

public class User {
private String name;
private int age ;
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public int getAge() {
	return age;
}
public void setAge(int age) {
	this.age = age;
}
public User(String name, int age) {
	super();
	this.name = name;
	this.age = age;
}
@Override
public String toString() {
	return "姓名：" + name + ", 年龄：" + age ;
}

}

public class MapLianXi<K,V> {
		public void add(V key){
			
		}
		public K get(K k){
			return null;
		}
	}

1.HashMap（可以有null值null键）

TableMap:不可以有null值null键
HashMap：可以有null值null键

2.TreeMap

package com.sxt.lianxi.map;

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class MapLianXi{
public static void main(String[] args) {
//	MapLianXi<User, Goods> map=new MapLianXi<>();
//	System.out.println(map);
	Map map=new TreeMap<>();
	map.put("a", "aaa");//添加key,value
	map.put("b", "bbb");
	print(map);
	System.out.println("--------------");
	Object V= map.get("a");//获取Value值
	System.out.println(V);
//	System.out.println(map.size());//获取集合长度
//	map.clear();//清除
//	map.values();
//	System.out.println(s);
//	map.forEach(null);
	boolean V1=map.replace("a", "aaa", null);
	System.out.println(V1);
//	 boolean b=map.containsValue("xx");
//	 System.out.println(b);//是否包含该Value
	boolean k=map.containsKey("a");
	System.out.println(k);
	map.remove("a");//删除
	print(map);
//	print(map);
}
private static void print(Map map) {
	Set keySet =map.keySet();
	for(Object o:keySet){
		System.out.println(o);
	}
	Set entrySet=map.entrySet();
//	for(Object key:entrySet){
//		System.out.println(key);
//		System.out.println(key+"-------->"+map.get(key));
//	}
//	for(int i=0;i<map.size();i++){
//		System.out.println(map);
//	}
}

}

3.properties（父类是Map）

配置文件：一般在代码中只读，不改，若要修改只需在文件中手动修改
常用方法：load（加载），getProperties（K）（根据传入的key值返回Value）,put(读)，store(写入，存)

(三)泛型 <类型参数声明>

出现：解决数据不统一
本质：参数化类型，即操作的数据类型被指定为一个参数，我理解为可以作为一个参数来传递
方法的泛型：位于方法返回类型之前，类型参数声明可以有多个类型参数。
例：pubic static <String,Student> void T(){}
类的泛型:位于类名之后,可以有多个类型参数。
例：public class Text<T,M,B>{}
有界的参数类型（类型参数名称 extends 上界）。
例：public <A extends Number> void Text(){}
只能传入Number类型的参素，不能是String等其他的
类型参数只能为引用类型，不能为基本类型（int,double等8种）
类型通配符？代替所有的具体参数例:List<?>,可以理解为所有List的父类

(四)Collections(集合工具类)

类比Arrays

常用方法：sort,synchronized,shuffle

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import javax.jws.Oneway;
import com.sxt.gdemo1.User;
public class TestUtils {
	public static void main(String[] args) {
		List<String> list=new ArrayList<>();
		list.add("asdsadsa");
		list.add("asd");
		list.add("sdfdf");
		list.add("asfd");
//		print(list);
//		Collections.sort(list);// 集合中的数据一定是可排序的（Comparable），或者重载传递比较器
//		Collections.sort(list, c);// 重载，需要比较器
//		print(list);
//		Collections.reverse(list);// 倒序。reverse（翻转）
//		Collections.sort(list);
//		print(list);
//		int binarySearch = Collections.binarySearch(list, "asfd", new Comparator<String>() {
//
//			@Override
//			public int compare(String o1, String o2) {
//				// TODO Auto-generated method stub
//				return o1.compareTo(o2);
//			}
//		});
//		System.out.println(binarySearch);
		print(list);
		//synchronized 都是将不同步集合转换成同步的集合（将线程不安全的转换称线程anquande）；
//		List<String> synchronizedList = Collections.synchronizedList(list);
//		Collections.shuffle(list);// 随机排放集合中元素的位置，类似洗牌
//		print(list);
		// 将数组转换称集合。
//		String[] array = list.toArray(new String[]{});
	 List<String> asList = Arrays.asList(new String[]{"sdas"});
	}
	private static void print(List<String> list) {
		// TODO Auto-generated method stub
		for(String str:list){
			System.out.println(str);
		}
		System.out.println("---------------");
	}
//class NameCom implements Comparator<User>{

//	@Override
//	public int compare(String o1, String o2) {
//		// TODO Auto-generated method stub
//		return 0;
//	}
//
//	@Override
//	public int compare(User o1, User o2) {
//		// TODO Auto-generated method stub
//		return 0;
//	}
//	
//}
}