黑马程序员——Java语言：集合

最新推荐文章于 2020-07-20 19:23:54 发布
最新推荐文章于 2020-07-20 19:23:54 发布
阅读量359 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GaoDosong/article/details/48849941
版权

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

一、集合框架

集合类的由来：

对象用于封装特有数据，对象多了需要存储；如果对象的个数不确定，就使用集合容器进行存储。

集合特点：

1. 用于存储对象的容器。

2. 集合的长度是可变的。

3. 集合中不可以存储基本数据类型值。

集合容器因为内部的数据结构不同，有多种具体容器。

不断的向上抽取，就形成了集合框架。

P.S.

数组和集合类同是容器，有何不同？

数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。

数组中可以存储基本数据类型，集合只能存储对象。


1.1 Collection接口

Collection 层次结构中的根接口

Collection的常见方法：

1、添加：

boolean add(Object obj);

boolean addAll(Collection coll);

2、删除：

boolean remove(Object obj);

boolean removeAll(Collection coll);

void clear();

3、判断：

boolean contains(Object obj);

boolean containsAll(Collection coll);

boolean isEmpty();判断集合中是否有元素。

4、获取：

int size();

Iterator iterator();

取出元素的方式：迭代器。该对象必须依赖于具体容器，因为每一个容器的数据结构都不同，所以该迭代器对象是在容器中进行内部实现的，也就是iterator方法在每个容器中的实现方式是不同的。对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，也就是iterator方法。

Iterator接口就是对所有的Collection容器进行元素取出的公共接口。

5、其他：

boolean retainAll(Collection coll);取交集

Object[] toArray();将集合转成数组

练习：

import java.util.*;

class CollectionDemo
{
	public static void main(String[] args)
	{
		method1();
		sop("-----------------");
		method2();
		sop("-----------------");
		method_get();
	}
	public static void method1()
	{
		//创建一个集合容易，使用Collection接口的子类
		ArrayList al = new ArrayList();
		
		//1.添加元素
		al.add("java1");
		al.add("java2");
		al.add("java3");
		al.add("java4");
		sop(al);
		
		//2.删除元素
		al.remove("java2");
		//al.clear();// 清空集合
		
		//3.获取个数，集合长度
		sop("size:"+al.size());
		sop(al);
		
		//4.判断元素
		sop("java3是否存在："+al.contains("java3"));
		sop("集合是否为空："+al.isEmpty());
		
	}
	public static void method2()
	{
		ArrayList a1 = new ArrayList();
		ArrayList a2 = new ArrayList();
		
		a1.add("java1");
		a1.add("java2");
		a1.add("java3");
		a1.add("java4");
		a2.add("java1");
		a2.add("java22");
		a2.add("java5");
		a2.add("java6");
		
		//a1.retainAll(a2);//取交集：a1中只会保留和a2中相同的元素
		a1.removeAll(a2);//去交集
		sop("a1:"+a1);
		sop("a2:"+a2);
	}
	
	public static void method_get()
	{
		ArrayList a1 = new ArrayList();
		
		a1.add("java1");
		a1.add("java2");
		a1.add("java3");
		a1.add("java4");
		
		//Iterator it = a1.iterator();//获取迭代器，用于取出集合中的子元素
		/*
		while(it.hasNext())
		{
			sop(it.next());
		}
		*/
		for(Iterator it = a1.iterator();it.hasNext();)
		{
			sop(it.next());
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

二、List、Set

Collection

|--List :元素是有序的，元素可以重复，因为该集合体系有索引

|--ArrayList 底层的数据结构使用的是数组结构。特点：查询速度快，但是增删慢。 线程不同步

|--LinkedList 底层使用的是链表数据结构。特点：增删快，查询慢

|--Vector 底层是数组数据结构，线程同步，被ArrayList替代

|--Set： 元素是无需的，元素不可以重复

2.1 List

List：特有方法：凡是可以操作角标的方法都是该体系特有的方法

增 add(index,element)

    addAll(index,Collection)

删 remove(index)

改 set(index,element)

查 get(index)

   subList(from,to)

   listIterator()

   indexOf();

   lastIndexOf();

练习:

import java.util.*;
class ListDemo
{
	public static void main(String[] args)
	{
		ArrayList al = new ArrayList();
		al.add("java1");
		al.add("java2");
		al.add("java3");
		
		sop("原集合："+al);
		
		al.add(1,"java9");
		sop("add集合："+al);
		
		al.remove(2);
		sop("remove集合："+al);
		
		al.set(2,"java00");
		sop("set集合："+al);
		
		sop("al(1):"+al.get(1));
		
		for(int x=0;x<al.size(); x++)
		{
			System.out.println("al("+x+"):"+al.get(x));
		}
		
		Iterator it = al.iterator();
		while(it.hasNext())
		{
			sop("next:"+it.next());
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

2.1.1 ListIterator

1、概述

ListIterator是List集合特有的迭代器，是Iterator的子接口。在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所以在迭代器时，只能用迭代器的方法操作元素。可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作。如果想要其他的操作，如添加、修改等，就需要使用其子接口：ListIterrator。该接口只能通过List集合的ListIterator方法获取。

2、ListIterator特有的方法

add(obj);//增加

set(obj);//修改为obj

hasPrevious();//判断前面有没有元素

previous();//取前一个元素

2.1.2 ArrayList、Vector、LinkedList

LinkedList 特有方法

addFirst()

addLast()

getFirst()

getLast() 

获取元素，如果集合为空，出现NoSuchElementException

removeFirst() 

reomveLast() 

取出并删掉，如果集合为空，出现NoSuchElementException

在jkd1.6出现替代方法

offerFirst()

offerLast()

peekFirst()

peekLast()

获取元素，如果集合为空，返回null

pollFirst()

pollLast()

获取并移除，如果集合为空返回null

1、练习基本功能：

import java.util.*;
class LinkedListDemo
{
	public static void main(String[] args)
	{
		LinkedList l = new LinkedList();
		l.addFirst("java1");
		l.addFirst("java2");
		l.addFirst("java3");
		l.addFirst("java4");
		sop(l.size());
		sop(l.removeFirst());
		sop(l.size());
		sop(l);
		
		while(!l.isEmpty())
		{
			sop(l.removeFirst());
		}
		
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

3、去除ArrayList中重复的元素

import java.util.*;

class ArrayListTest
{
	public static void main(String[] args)
	{
		ArrayList al = new ArrayList();
		
		al.add("java1");
		al.add("java1");
		al.add("java2");
		al.add("java2");
		al.add("java3");
		
		sop(al);
		
		al = singleElement(al);
		
		sop(al);
		
	}
	public static ArrayList singleElement(ArrayList al)
	{
		ArrayList newal = new ArrayList();
		
		Iterator it = al.iterator();
		
		while(it.hasNext())
		{
			Object obj = it.next();
			
			if(!newal.contains(obj))
			{
				newal.add(obj);
			}
		}
		
		return newal;
		
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}



2.2 Set

Set元素不可以重复，是无序。

Set接口中的方法和Collection一致。

|--HashSet：内部数据结构是哈希表，是不同步的。

|--TreeSet：可以对Set集合中的元素进行排序，是不同步的。

 

2.2.1 HashSet

如何保证元素的唯一性：hashCode和equals

如果元素的hashCode值相同，才会判读equals是否为true

如果元素的hashCode值不同，就不会调用equals

注意，对于判读元素是否存在或者删除等操作，依赖的是元素的hashCode和equals方法

/*
往HashSet集合中存入自定义对象
姓名和年龄相同为同一个人，为重复元素
*/
import java.util.*;
class HashSetTest
{
	public static void main(String[]args)
	{
		HashSet hs = new HashSet();
		hs.add(new Person("a",11));
		hs.add(new Person("b",12));
		hs.add(new Person("c",13));
		hs.add(new Person("d",14));
		//hs.add(new Person("d",14));
		 
		sop("a:"+hs.contains(new Person("a",11)));
		
		
		Iterator it = hs.iterator();
		
		while(it.hasNext())
		{
			Person p = (Person)it.next();
			
			sop(p.getName()+".."+p.getAge());
			
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}
class Person
{
	private String name;
	private int age;
	Person(String name, int age)
	{
		this.name = name;
		this.age = age;
	}
	 public int hashCode()
	 {
		 System.out.println(this.name+"....hashCode");
		 return name.hashCode()+age*2; //保证哈希值唯一
	 }
	 public boolean equals(Object obj)
	{
		if(!(obj instanceof Person))
			return false;
		
		Person p = (Person)obj;
		System.out.println(this.name+"..equals.."+p.name);
		return this.name.equals(p.name) && this.age == p.age;
	}
	 
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	
}


2.2.2 TreeSet 

可以对Set集合中的元素进行排序，底层数据结构是二叉树。

保证元素唯一性的依据：compareTo方法

1、TreeSet排序的第一种方式：让元素自身具备比较性，

元素需要实现compareable接口，覆盖compareTo方法

这种方法也称为元素的自然顺序，或者叫做默认顺序

2、TreeSet排序的第二种方式：当元素自身不具备比较性

或者具备的比较性不是所需要的，这时就需要让集合自身具备比较性

集合初始化时就已经有了比较方式

下面的代码就实现的元素的比较性和集合的比较性

import java.util.*;
class TreeSetDemo2
{
	public static void main(String[] args)
	{
		TreeSet ts = new TreeSet(new Compare());
		ts.add(new Student("haha12",1));
		ts.add(new Student("hehe2442",2));
		ts.add(new Student("adffg",3));
		ts.add(new Student("abffg",3));
		ts.add(new Student("adffg",5));
		
		Iterator it = ts.iterator();
		
		while(it.hasNext())
		{
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}	
	}
}
class Student implements Comparable //该接口强制让学生具备比较性
{
	private String name;
	private int age;
	Student(String name, int age)
	{
		this.name = name;
		this.age = age;
	}
	
	public int compareTo(Object obj)
	{
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
		Student s = (Student)obj;
		
		if(this.age>s.age)
			return 1;
		if(this.age==s.age)
		{
			return this.name.compareTo(s.name);
		}
		return -1;
	}
	
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	
}

class Compare implements Comparator
{
	public int compare(Object o1,Object o2)
	{
		Student s1 = (Student)o1;
		Student s2 = (Student)o2;
		
		int num = s1.getName().compareTo(s2.getName());
		if(num==0)
		{
			return new Integer(s1.getAge()).compareTo(s2.getAge());
		}			
		return num;
	}
}

三、Map

接口 Map<K,V>

Map集合：该集合存储键值对，而且要保证键的唯一性,一次添加一对元素.

Map

     |--Hashtable 底层是哈希表数据结构，不可以存入null键null值，该集合线程同步

     |--HashMap 底层是哈希表数据机构，允许使用 null 值和 null 键。该集合不同步，效率高

     |--TreeMap 底层是二叉树结构，不同步，可以用于给Map集中的键排序

和Set很像，其实Set底层就是使用了Map集合

1.添加

V put(K key, V value)    添加相同键的值时，新的值会覆盖旧的值，并返回旧值

void putAll(Map<? extends K,? extends V> m)  

2.删除

void clear() 

V remove(Object key)  

3.判断

boolean containsKey(Object key) 

boolean containsValue(Object value) 

boolean isEmpty()  

4.获取

V get(Object key) 

int size()  

Collection<V> values() 

Set<Map.Entry<K,V>> entrySet()  

Set<K> keySet() 

import java.util.*;

class MapDemo
{
	public static void main(String[] args)
	{
		Map<String,String> m = new HashMap<String,String>();
		m.put("1","haha1");
		m.put("2","haha2");
		m.put("3","haha3");
		  
		System.out.println(m.containsKey("1"));
		System.out.println(m.containsKey("11"));
		System.out.println(m);
		System.out.println(m.remove("1"));
		System.out.println(m);
		
		m.put("4",null);//m.put("4",null)可以使用 null 值和 null 键
		System.out.println(m);
		System.out.println(m.values());	
	}
}


Map集合的两种取出方式

1.keySet  Set<k>将Map中所有的键存入到Set集合中，因为Set具备迭代器

所以可以迭代方式取出所有键，再根据get方法，获取每一个键的对应值

import java.util.*;

class MapDemo
{
	public static void main(String[] args)
	{
		Map<String,String> m = new HashMap<String,String>();
		m.put("1","haha1");
		m.put("2","haha2");
		m.put("3","haha3");
		  
		System.out.println(m.containsKey("1"));
		System.out.println(m.containsKey("11"));
		System.out.println(m);
		System.out.println(m.remove("1"));
		System.out.println(m);
		
		m.put("4",null);//m.put("4",null)可以使用 null 值和 null 键
		System.out.println(m);
		System.out.println(m.values());	
	}
}

2.entrySet  Set<Map.Entry<kK,V>> 

将Map集合中的映射关系存入到set结合中，而这个关系的数据类型就是Map.Entry

Set<Map.Entry<String,String>> entryset = m.entrySet();
		Iterator<Map.Entry<String,String>> it = entryset.iterator();
		while(it.hasNext())
		{
			Map.Entry<String,String> me = it.next();
			String key = me.getKey();
			String value = me.getValue();
			System.out.println(key+"="+value);
		}
		System.out.println(m.entrySet());

练习：每一个学生都有对应的归属地，学生Studdent 地址 String，学生属性：姓名，年龄

注意：姓名和年龄相同视为同一个学生，保证学生的唯一性，对学生对象的名称进行排序

1.描述学生

2.定义Map容器，将学生作为键，地址作为值，存入

3.获取Map中的元素

4.要对学生进行排序，所以要使用可以排序的TreeMap集合

import java.util.*;
class MapTest
{
	public static void main(String[ ]args)
	{
		TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuComparator());
		tm.put(new Student("zhansan",1),"BJ");
		tm.put(new Student("lisi",1),"TJ");
		tm.put(new Student("lisi6",11),"BJ");
		tm.put(new Student("jdsd",2),"SH");
		tm.put(new Student("trc",3),"GZ");
		tm.put(new Student("wqqy",4),"SZ");
		System.out.println(tm);
		
		//第一种取出方式keySet
		Set<Student> keyset = tm.keySet();
		Iterator<Student> it = keyset.iterator();
		while(it.hasNext())
		{
			Student stu = it.next();
			String addr = tm.get(stu);
			System.out.println(stu+"="+addr);
		}
		System.out.println();
		//第二种取出方式 entrySet
		Set<Map.Entry<Student,String>> entryset = tm.entrySet();
		Iterator<Map.Entry<Student,String>> it1 = entryset.iterator();
		while(it1.hasNext())
		{
			Map.Entry<Student,String> me = it1.next();
			Student stu = me.getKey();
			String addr = me.getValue();
			System.out.println(stu+"=="+addr);
		}	
	}
}

class Student implements Comparable<Student>
{
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	public int hashCode()
	{
		return name.hashCode()+age*2;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Student))
			throw new ClassCastException("类型不匹配");
		
		Student s = (Student)obj;
		return this.name.equals(s.name) && this.age==s.age;
	}
	public int compareTo(Student s )
	{
		int num = new Integer(this.age).compareTo(new Integer(s.age));
		
		if(num==0)
			return this.name.compareTo(s.name);
		return num;
	}
	public String toString()
	{
		return "("+name+"+"+age+")";
	}
	
}
class StuComparator implements Comparator<Student>
{
	public int compare(Student s1,Student s2)
	{
		int num = s1.getName().compareTo(s2.getName());
		if (num==0)
			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
		
		return num;
	}
}



GaoDosong
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
黑马程序员——java的集合类
hgdswj的博客
06-28 538
------- android培训、java培训、期待与您交流！ ---------- 前言：通过观看毕向东老师的java基础视频，查漏补缺，将一些自己掌握的还不牢固的知识写出来，希望和大家交流分享。 1.集合框架 1.java集合框架的构成，由于数据结构的不同，有不同的集合，也叫容器。如下图： 2.集合类的出现原因：为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的
黑马程序员——Android移动开发源码
04-29
黑马程序员——Android移动开发源码
带你了解Java编程语言具有哪些优点！
IT_studied的博客
07-20 325
　　Java作为一种年轻具有活力的编程语言，在最近几年是越来越受到市场的欢迎。它作为面向网络的程序设计语言，用来让程序员创建应用程序。Java是个面向对象的语言，由于它自身具备的入门门槛低等优点。那么，Java编程语言具有什么优点?接下来，就跟着小千一起来了解下吧! 　　1.Java语言是简单的 　　Java语言的语法与C语言和C++语言很接近，使得大多数程序员很容易学习和使用。另一方面，Java丢弃了C++中很少使用的、很难理解的、令人迷惑的那些特性，如操作符重载、多继承、自动的强制类型转换。Ja
黑马程序员-Java基础：集合
BlackHorseKevin的博客
08-13 592
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-集合总结一、集合概述 1.概述集合是Java中用于存储对象的容器，由于Java是面向对象的语言，为了方便对多个对象进行操作，同时解决数组长度固定，不能满足变化需求的问题，因此提供了集合类。 集合的两个关键特点： <1>长度可变 <2>可以存储任意类型的对象(不可以存储基本数据类型，但可以存储基本数据类型包装
黑马程序员——集合Collection：体系详述
heimawoo的博客
09-24 1938
本文综合了老师的课程内容以及维基百科上的多方面内容，对集合体系中的常见类型及其操作进行了系统的总结。其中包含了Collection通用方法，List、Set、Map等方面，文章的精华内容在对代码的注释以及实现上。所有代码均亲自在Eclipse中调试运行，程序的输出结果以注释的方式放在代码段中。
黑马程序员——Java基础——集合（三）
maidou51的博客
11-25 366
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- Collection接口： package cu.fu._06collection; /** * Collection接口 * 集合框架的顶层是Collection接口: * 常见方法: * 1.添加 * boolean add(Object obj); * boolea
黑马程序员——Java基础——集合（一）
maidou51的博客
11-18 435
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- String类： package cn.fu._01string; /** * String StringBuffer StringBuilder * String类的特点: * 字符串对象一旦被初始化就不会改变. */ public class StringDemo1 { pu
黑马程序员——Java集合
daiqingmingg的博客
10-19 386
------http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 1.  Java集合分类： （1）Collection接口：        有两个子接口List和Set，        List接口：使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（
黑马程序员——Java语言--集合框架
朦胧色彩
11-03 629
———–android培训、java培训、java学习型技术博客、期待与您交流！———— 集合框架由来 对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定，就是用集合容器进行存储。 集合容器因为内部的数据结构不同，所以有多种具体容器，不断地向上抽取，就形成了集合框架体系。 特点 是用于存储对象的容器。集合的长度是可变的。集合中不可以存储基本数据类型值
黑马程序员——java基础之集合
back
01-04 461
java 集合框架: 面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式
黑马程序员-Java语言进阶-源码、教程笔记.zip
12-16
day01_Object类、常用API day02_Collection、泛型 day03_List、Set、数据结构、Collections day04_Map，斗地主案例 day05_异常，线程 day06_线程、同步 day07_等待与唤醒案例、线程池、Lambda...Java基础小节练习题答案
黑马程序员入学Java知识——精华总结.doc
05-09
Java是SUN(Stanford University Network，斯坦福大学网络公司)1995年推出的一门高级语言。是一种面向Internet的编程语言。 随着Java技术在web方面的不断成熟，已经成为Web应用程序的首选开发语言。是简单易学，完全...
黑马程序员java培训就业班笔记：day10总结JAVA语言
03-26
黑马程序员java培训就业班笔记：day10总结
黑马程序员：轻松精通Java学习路线基础篇!JAVA语言
03-26
3. Java 概述：了解 Java 语言的发展史、Java 语言平台版本、Java 语言的特点，以及 JRE 与 JDK。 4. JDK 环境安装配置：了解 JDK 的重要性，学习如何安装和配置 JDK 环境，并下载不同的 JDK 版本。 5. 环境变量配置...
建筑结构\施工图\B型施工图-建筑-别墅结构施工图.dwg
06-17
建筑结构\施工图\B型施工图-建筑-别墅结构施工图.dwg
tensorflow-2.8.1-cp39-cp39-win-amd64.whl
06-17
python安装
protobuf-3.15.6-cp36-cp36m-macosx_10_9_x86_64.whl
06-17
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
pyzmq-23.0.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl
最新发布
06-17
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
黑马程序员24-2：序列化与反序列话
05-23
序列化和反序列化是编程中常用的概念，它们通常用于将对象转换成可以存储或传输的格式，或者将存储或传输的数据转换成对象。 序列化指的是将一个对象转换成一串二进制数据的过程，这个过程也称为将对象“打包”。序列化后的数据可以被存储或传输，比如可以将一个序列化后的对象保存到文件中，或者通过网络传输给另一个程序。序列化的过程通常是将对象的属性依次转换成字节流，然后再将这些字节流拼接起来得到一个二进制数据流。 反序列化指的是将序列化后的数据转换回原来的对象的过程，这个过程也称为将对象“解包”。反序列化的过程通常是将字节流按照序列化时的顺序依次还原成对象的属性值，并返回一个新的对象。 序列化和反序列化在很多场景下都很有用，例如在分布式系统中可以将对象序列化后传输给另一个节点，或者在本地缓存中将对象序列化后存储到磁盘上。在Java中，可以使用ObjectOutputStream和ObjectInputStream类进行序列化和反序列化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值