Java集合与泛型学习笔记

1：Java集合类

首先我们思考为什么出现集合类？
理由：
1面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象操作，就对对象进行储存，集合就是储存对象最常用的一种方式
2 数组和集合同是容器，有何不同？
数组虽然也可以储存对象，当是长度固定的。集合长度是可变的 。数组可以储存基本数据类型，集合只可以储存对象引用（地址）（可以是不同类型的对象引用）

Java集合和接口共同组成Java集合框架

Java集合框架中有许多容器（边框），为什么有这么多容器（边框）？
每一个边框（容器）对数据的储存方式都有不同 （这个储存方式叫数据结构）

注：java集合框架中有许多的接口和类我们只要求掌握Collection接口， List接口， Set接口，ArrayList类，Linkedlist类，HashSet类，TreeSet类，HashMap类，TreeMap类，以上的类与接口下面会一一概述

Collection接口下的两个List接口，Set接口。
List接口：元素是有序的，元素可以重复，应为有索引
Set接口：元素是无序的，不可以重复

1：List接口

1：ArrayList类

每个ArrayList实例都有一个容量 。 容量是用于存储列表中的元素的数组（数据结构）的。 它总是至少与列表大小一样大。
当元素添加到ArrayList时，其容量（数组）会自动增长。 没有规定增长政策的细节，除了添加元素具有不变的摊销时间成本。

ArrayList是最常用的List接口的实现类，他使用数组作为其内部储存的结构。（线程不同步）

List接口，提供的是一个有序的集合，且List允许有重复的元素。（所有集合类都实现了Iterator）

我们在这引入一个概念：迭代器
什么是迭代器？
可在容器（数组，链表）上访问的接口 （这是一个接口）

查询API文档可以找到这个方法在Collection接口及他的子类中都有出现，如下
Iterator iterator() 方法作用：
以正确的顺序返回该列表中的元素的迭代器。

Iterator接口中含有的方法：
1： boolean hasNext()
如果迭代具有更多元素，则返回 true 。
:2： E next()
返回迭代中的下一个元素。

注：
1：List集合接口特有的迭代器：ListIterator(Iterator接口的子接口）
2： 在迭代时，不可以通过集合对象的方法操作集合中的元素，会发生并发性异常。
所以只可以使用Iterator方法，但该方法有限，所以要使用ListIterator方法

如下代码我们将介绍ArrayList类中的常用方法应用，读者应自行查阅API动手实践

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.ListIterator;
public class ArrayListDemo1 {
  public static void main(String args[]) {
	  
	  /*ArrayList<String>的解释：使用泛型技术，表示这个ArrayList用来储存String对象
	   * 
	   * *创建一个集合容器（边框），使用Collection接口子类：ArrayList
	   * 
	   */
	  
	  
	   
	  ArrayList <String> a=new ArrayList<String>();   
	  Collection <String> c=new ArrayList<String>();   
	  a.add("one");      //Collection接口的方法：将对象添加给集合
	  a.add("two");
	  c.add("three");
	  c.add("four");
	  c.add("four");
	  a.addAll(c);       //Collection接口的方法：将c集合中所有元素添加给该集合
	  a.add(1,"zero");
	  a.remove(2);          //List接口的方法：删除指定位置上的元素
	  a.remove("three");    //Collection接口的方法：如果集合中有与“three”匹配的对象，就删除
	  System.out.println("是否含有该对象"+a.containsAll(c)); ////Collection接口的方法：查找集合中是否含有对象c中所有元素
	  System.out.println("是否含有该对象"+a.contains("three"));  //Collection接口的方法：查找集合中是否含有对象“three”
	  
	  System.out.println("Iterator迭代器的使用");  //
	  Iterator <String> ite=a.iterator(); 
	  while(ite.hasNext()) {     // Ireator接口的方法：判断是否存在另一个可访问元素
		  
		  System.out.println(ite.next());  //Ireator接口的方法：返回要访问的下一个元素
		  
	  }
	  
	  System.out.println("ListIterator迭代器的使用");  //

	  ListIterator <String> ites=a.listIterator(); 
	  while(ites.hasNext()) {     // Ireator接口的方法：判断是否存在另一个可访问元素
		  
		  String obj=ites.next();

		  if (obj.equals("one")) {
			  
			  ites.remove();
			ites.add("five");

		}
		  
		  System.out.println(obj);  //Ireator接口的方法：返回要访问的下一个元素
		  
	  }
	  
	  System.out.println("指定位置的元素"+a.get(0)); //List接口的方法：返回List中指定位置的元素
	  System.out.println("指定位置的元素"+a.get(2)); //List接口的方法：返回List中指定位置的元素
	  System.out.println("返回第一个出现元素指定位置的元素"+a.indexOf("four"));//List接口的方法：返回List中第一个出现“four”元素的指定位置的元素
	  System.out.println("返回最后一个出现元素指定位置的元素"+a.lastIndexOf("four"));//List接口的方法：返回List中最后一个出现“four”元素的指定位置的元素

	  
  }
}

运行结果

ArrayList类的问题：
将自定义对象作为元素存到ArrayList集合中,并去除重复元素
比如存人对象，同姓名，同年龄，为重复元素

思路：
1：对人描述，间数据封装进入对象
2：定义容器（边框），将人存入
3：取出

class Person {

	private String name;
	private String age;

	public Person(String name, String age) {

		this.age = age;
		this.name = name;

	}

	public String getName() {

		return name;

	}

	public String getAge() {

		return age;

	}

	public boolean equals(Object object) {//这个方法是底层自动调用,（不重写该方法，该方法的作用就是*判断是否有相同的对象*。所以结果原样输出，重写该方法后，作用变了）

		if (!(object instanceof Person)) {

			return false;

		}
		Person person = (Person) object;
//	  System.out.println(this.name + "..." + person.name);//该输出可以看底层的实现

		return this.name.equals(person.name) && this.age==person.age;
	}

}

public class ArrayListProblem {

	public static void print(Object object) {

		System.out.println(object);

	}

	public static ArrayList<Person> deleteSamePerson(ArrayList<Person> person) {

		ArrayList<Person> arrayList = new ArrayList<Person>();

		Iterator<Person> iterator = person.iterator();

		while (iterator.hasNext()) {

			Object object = iterator.next();
			Person person2 = (Person) object;
			 if(!(arrayList.contains(person2))) {// 调用了重写的equals（）方法

				arrayList.add(person2);

			}

		}
		return arrayList;

	}

	public static void main(String[] args) {

		ArrayList<Person> a = new ArrayList<Person>();

		a.add(new Person("zlj", "12"));// Object object=new Person("zlj", "12")
		a.add(new Person("zlj", "12"));
		a.add(new Person("zlj", "12"));
		a.add(new Person("lqx", "24"));
		a.add(new Person("zzg", "36"));
		a.add(new Person("zzg", "36"));
		a.add(new Person("hl", "46"));

		Iterator<Person> iterator = a.iterator();

		while (iterator.hasNext()) {

			Object object = iterator.next();
			Person b = (Person) object;
			print(b.getAge() + ".." + b.getName());
		}

		deleteSamePerson(a);
		System.out.println("删除相同人后的数组");
		
		Iterator<Person> iterators =deleteSamePerson(a) .iterator();

		while (iterators.hasNext()) {

			Person b = (Person) iterators.next();

			print(b.getAge() + ".." + b.getName());// 字符串对象引用object=字符串内容

		}

	}

}

运行结果如下

2：LinkedList类

LinkedList是基于链表（数据结构）实现的，其中的每个元素其实是每个节点的内部。

LinkedList类同时实现了List和Deque接口。

Deque接口 ：Deque 表示双端队列。 双端队列是在两端都可以进行插入和删除的队列。 Deque 是一个比 Stack 和 Queue 功能更强大的接口，它同时实现了栈和队列的功能

查阅API文档我们可以利用Deque接口中的方法来写出栈和队列的代码示例

队列代码示意

package zlj;

import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListQueueDemo {
	
	public static void main (String args[]) {
		
		System.out.println("队列演示：");
		LinkedList<Integer>  queue =new LinkedList<Integer>();
		
		System.out.println("现在队列的排序顺序：");
		queue.add(1);
		queue.add(2);
		queue.add(3);
		queue.add(4);
		Iterator<Integer> iterators=queue.iterator();
		while (iterators.hasNext()) {
			
			System.out.println(iterators.next()+"   ");
			
		}
		
	    queue.poll();
	    System.out.println("输出使用queue.poll()方法后，现在列表的第一个元素"+queue.getFirst());//使用poll（）方法后，数组大小就变成三了；
	    System.out.println("输出使用queue.poll()方法后，现在列表的第二个元素"+queue.get(1));
	    System.out.println("输出使用queue.poll()方法后，现在列表的第三个元素"+queue.get(2));

	    System.out.println("输出使用queue.poll()方法后，队列的排序顺序");
	    Iterator<Integer>  iterator=queue.iterator();
	    while (iterator.hasNext()) {

	      System.out.print(iterator.next()+" ");	
	    	
		}
	}
}

运行结果

栈的代码示例

package zlj;

import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListStackDemo {

	public static void main(String[] args) {

		System.out.println("栈演示");
		LinkedList<Integer> stack=new LinkedList<Integer>();
		
		System.out.println("现在栈的排列顺序");
		stack.addFirst(1);
		stack.addFirst(2);
		stack.addFirst(3);
		stack.addFirst(4);
		
		Iterator<Integer> iterators=stack.iterator();
		
		while (iterators.hasNext()) {
			
			System.out.println(iterators.next());
			
		}
		
		stack.remove();
		System.out.println("输出使用stack.remove();方法后，当前的第一个元素"+stack.get(0));
		System.out.println("输出使用stack.remove();方法后，当前的第二个元素"+stack.get(1));
		System.out.println("输出使用stack.remove();方法后，当前的第三个元素"+stack.get(2));

		System.out.println("输出使用stack.remove();方法后，当前栈队列中的排序顺序");
		Iterator<Integer> interaIterator =stack.iterator();
		while (interaIterator.hasNext()) {
			
			System.out.println(  interaIterator.next() + " ");

		}

	}

}

运行结果

2：Set接口

1：HashSet类

set接口功能和collection接口是一致的

HashSet：底层数据结构是哈希表。

HashSet是如何保证元素的唯一性呢？
通过元素的两个方法equals（）和 hashCode（）来完成。
如果元素的hashCode（）方法返回值相同，才会判断equals（）方法返回值是否为true
如果元素的hashCode（）方法返回值不相同，不会调用判断equals（）方法
所以，应该要为存放到HashSet集合的自定义类对象定义 equals（）和 hashCode（） 方法。

HashSet集合判断两个元素相等的标准：1.equals（）方法2.两个对象的hashCode（）方法返回值也相等

数据结构不同依赖的方法判断也不一样，ArrayList依赖于equals（），HashSet依赖于equals（）和hashCode（）

下面代码演示HashSet的运用

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

class Persons {

	int age;
	String name;

	public Persons(int age, String name) {

		this.age = age;
		this.name = name;

	}

	// @Override
	public int hashCode() {

		//System.out.println(this.name + ".....hashCode");
		return age * 37 + name.hashCode();// 底层自动调用该方法，id*37+name.hashCode()：乘37的意思是，保证哈希值唯一（提高效率，减少equals（）方法的调用）

	}

	// @Override
	public boolean equals(Object object) {// 底层自动调用该方法

		if (!(object instanceof Persons)) {

			return false;

		}
		Persons person = (Persons) object;

	//	System.out.println(this.name + "..." + person.name);

		return this.name.equals(person.name) && this.age == person.age;

	}

	// @Override
	public String toString() {

		return age + ":" + name;

	}
}

public class HashSetDemo1 {

	/*
	 * main函数可以保证该独立运行 它是程序的入口 它会被jvm调用
	 */

	public static void main(String args[]) {

		System.out.println("删除了相同年龄和姓名后的排列顺序");
		HashSet<Persons> a = new HashSet<Persons>();

		a.add(new Persons(12, "zlj"));
		a.add(new Persons(32, "hl"));
		a.add(new Persons(32, "hl"));
		a.add(new Persons(32, "lqx"));
		
	//	System.out.println("是否含有对象"+a.contains(new Persons(12, "zlj")));
	//	System.out.println("是否含有对象,有就删除"+a.contains(new Persons(12, "zlj")));

		Iterator<Persons> inte = a.iterator();
		while (inte.hasNext()) {

			System.out.println(inte.next());

		}
	}
}

运行结果如下

该结果说明HashSet类自动调用了equals（）和hashCode（）方法来删除相同元素

2：TreeSet类

TreeSet：可以对Set集合中的元素进行排序（底层数据结构是二叉树（默认从小到大排序））

注：Tree类会帮你排序，但是如果你没有把排序的方式告诉他，他就会出错 thorws ClassCastException（ClassCastException - 如果指定的对象的类型阻止它与该对象进行比较。）.

该类支持两种排序:1,自然排序2,定制排序单位
1： TreeSet排序的第一种方式：让元素自身具备比较性，元素要实现Comparable接口中的compareTo方法（自然排序）
2： TreeSet排序的第二种方式：当元素自身不具备比较性，这时需要让集合（容器）（边框）自身具备比较性。定义比较器，将比较器对象作为参数传递给TreeSet集合的构造函数（定义一个类，实现Comparator接口，覆盖compare方法）

注：这两种排序方法中的接口和方法，请读者自行查阅API文档，理解，如下作简要介绍

1 public interface Comparable
该接口对实现它的每个类的对象强加一个整体排序。 这个排序被称为类的自然排序 ，类的compareTo方法被称为其自然比较方法 。
2 TreeSet(Comparator<? super E> comparator)
构造一个新的，空的树集，根据指定的比较器进行排序。

使用第一种排序方法的问题：
往TreeSet集合中储存自定义对象学生，并按照学生年龄排序

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

class Student1 implements Comparable<Student1> { // 该接口强制让学生具备比较性

	int age;
	String name;

	public Student1(int age, String name) {

		this.age = age;
		this.name = name;

	}

	public String getName() {

		return name;

	}
	
	@Override
	public int compareTo(Student1 object) { // 自动调用该方法

		Student1 student1 = (Student1) object;

		System.out.println(this.age + ".....compareAge.." + student1.age);

		if (this.age > student1.age) {

			return 1;

		}
		if (this.age < student1.age) {

			return -1;

		} else {

			return this.name.compareTo(student1.name);

		}

	}

	public String toString() {

		return name + "  " + age;

	}
}
public class TreeSetDemo1 {

	public static void main(String args[]) {

		TreeSet<Student1> a = new TreeSet<Student1>();

		a.add(new Student1(1, "zlX"));
		a.add(new Student1(2, "lqx"));
		a.add(new Student1(3, "lqw"));
		a.add(new Student1(4, "lqf"));
		a.add(new Student1(4, "lqf"));
		a.add(new Student1(5, "lqf"));
		a.add(new Student1(5, "lqa"));

		Iterator<Student1> iterator = a.iterator();
		while (iterator.hasNext()) {

			System.out.println(iterator.next());

		}

	}
}

结果如下

使用第二种排序方法的问题：
往TreeSet集合中储存自定义对象学生，并按照学生年龄排序

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

class Student1  { // 该接口强制让学生具备比较性

	int age;
	String name;

	public Student1(int age, String name) {

		this.age = age;
		this.name = name;

	}

	public String getName() {

		return name;

	}
	public String toString() {

		return name + "  " + age;

	}

}
public class TreeSetDemo1 {

	public static void main(String args[]) {

		TreeSet<Student1> a = new TreeSet<Student1>(new Comparator<Student1>() {
			
			public int compare(Student1 student1, Student1 student2) {

				int num = student1.getName().compareTo(student2.getName());

				if (num == 0) {
					if (student1.age > student2.age) {

						return 1;
					} else {

						return -1;

					}

				}
				return num;
			}
			
		});

		a.add(new Student1(1, "zlX"));
		a.add(new Student1(2, "lqx"));
		a.add(new Student1(3, "lqw"));
		a.add(new Student1(4, "lqf"));
		a.add(new Student1(4, "lqf"));
		a.add(new Student1(5, "lqf"));
		a.add(new Student1(5, "lqa"));

		Iterator<Student1> iterator = a.iterator();
		while (iterator.hasNext()) {

			System.out.println(iterator.next());

		}

	}
}

运行结果

3:Map接口

1HashMap类

Map接口特点：该集合储存键值对，保证唯一性。

注：1：一个map中不能有重复的键，应为map中的键——值对元素通过键来唯一标识，Map键用Set存放。
2：给定一个键和值，可以储存这个键值对到一个Map对象中。

HashMap类：基于哈希表的实现的Map接口

下面演示HashMap类中常用方法，读者自行查阅API文档，实践

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

public class HashMapDemo1 {

	public static void main(String[] args) {

		Map<String,String> a=new HashMap<String,String>();
		
		a.put("face","1");//Map方法：加入键值对元素
		a.put("leg","2");
		a.put("hand","3");
		a.put("arm","4");
		a.put("eye","4");
		a.put("ear","4");

		if(a.containsKey("face")){//Map方法：是否包含指定键的映射关系
			
			System.out.println("指定键face所对应的值"+a.get("face"));
			
		}
		System.out.println("是否该集合将一个或多个键映射到指定值为4的上面"+a.containsValue("4"));//Map方法：是否将一个或多个键映射到指定值

		
		System.out.println("使用set接口输出该哈希表键队值");
		Set<String> b=a.keySet(); //使用该Map方法：可以返回此Map集合中包含的键的Set的集合
		Iterator <String> c=b.iterator();//然后使用Set集合的Iterator接口对象遍历所有的key
		while(c.hasNext()) {
			
			String key=c.next();
			String value=a.get(key);
			System.out.println("键"+key+"---"+"值"+value);
		}
		/*
		 * Map.Entry 其实Entry也是一个接口，它是Map的一个内部接口。
		 * 
		 * Interface Map.Entry<K,V>
		 * 地图*条目*（键值对）。 Map.entrySet方法返回地图的集合视图，其元素属于此类。 获取对映射条目的引用的唯一方法是从该集合视图的*迭代器*。 这些*Map.Entry对象仅在迭代器*间有效; 
		 */
		System.out.println("使用Map.Entry<K,V>接口输出该哈希表键队值");
		Set<Map.Entry<String, String>> set=a.entrySet();
		Iterator<Map.Entry<String, String>> iterator=set.iterator();
		while (iterator.hasNext()) {
			
			       Map.Entry<String, String> aEntry=iterator.next();
			       
					System.out.println("键"+aEntry.getKey()+"---"+"值"+aEntry.getValue());

			
		}
		
			System.out.println("返回此地图中包含的值的Collection视图:");
			Collection<String> collection=a.values();
			System.out.println(collection);

			
		
	}
}

运行结果如下

下面看一个问题：
每一个学生都有对应的归属地，学生student，地址String
学生属性：姓名，年龄。
注意姓名和年龄相同的视为同一个学生，保证唯一性，按顺序输出

步骤：1：描述学生类
2：定义map容器，将学生作为建，地址作为值存入
3：获取map集合中的元素

代码如下

class Students implements Comparable<Students> {

	private int age;
	private String name;

	public Students(int age, String name) {

		this.age = age;
		this.name = name;

	}

	public int getAge() {

		return age;

	}

	public String getName() {

		return name;

	}
	
	public String toString() {
		
		return name+"..."+age;
		
	}
	public int compareTo(Students students) {
		
     	//    System.out.println("............");

	        if(students.getAge()>this.getAge()) {

	        	return 1;
	        	
	        }if(students.getAge()<this.getAge()) {
	        	
	        	return -1;
	        	
	        }else {
	        	
	        	return	    students.getName().compareTo(this.getName());

	        			
	        }
	}
	     public int hashCode( ) {
	     
          	// System.out.println();

	          return  this.getName().hashCode()+this.getAge()*22;

	     }
	     public boolean equals(Object object) {
	    	 
//          	 System.out.println("............");

	    	 Students student2=(Students) object;
	    	 
	    	return this.getName().equals(student2.getName())&&this.getAge()==student2.getAge();

		}
}

class HashMapProblemDemo {

	public static void main(String[] args) {

		HashMap<Students, String> hashMap=new HashMap<Students, String>();
		
		hashMap.put(new Students(18,"zlj"), "wuhan");
		hashMap.put(new Students(18,"zlj"), "wuhan");
		hashMap.put(new Students(20,"hl"), "beijin");
		hashMap.put(new Students(19,"yihu"), "fuzhou");
		hashMap.put(new Students(17,"zag"), "hunan");
		
		System.out.println("使用Map.Entry<K,V>接口输出该哈希表键队值");
		Set<Map.Entry<Students, String>> set=hashMap.entrySet();
		Iterator<Map.Entry<Students, String>> iterator=set.iterator();
		while (iterator.hasNext()) {
			
			Map.Entry<zlj.Students, java.lang.String> entry = iterator	.next();
			
			System.out.println(entry.getKey()+" ..."+entry.getValue());
			
		}
		
		System.out.println("使用set接口输出该哈希表键队值");
        Set<Students> set2 =hashMap.keySet();
         Iterator<Students>   iterators=set2.iterator();
         while (iterators.hasNext()) {
        	 
        	 Students key=iterators.next();
        	 String  value=hashMap.get(key);
        	 
        	 System.out.println(key+"............"+value);
		
		}
		
	}
}

运行如下

3：TreeMap类

reeMap:底层时二叉树数据结构，线程不同步，可以用于map集合中的键进行排序
TreeMap类中键–值对元素的键所属的类必须实现Comparable接口给出的compareto方法

下面来看一个问题
练习：aabbccddd获取该字符串中字母出现的次数

思路：
1：将字符串转化成字符数组
2：定义一个map集合，因为输出字母有顺序，所以使用treemap集合
3：遍历字符数组。
将每一个字母作为键去get（）map集合
如果返回null，将字母和1存入到map集合中
如果返回不是null，说明该字母在map集合中有对应的次数
那么获取该次数，进行自增，然后字母和次数存入到map集合中，覆盖原有的值
4：返回一个stringbuilder 对象引用，并输出

注：stringBuilder对象在做字符串连接时，是在原来字符串上修改，改善性能(String在做字符串连接时，在做连接操作时，都会创建一个新的对象，占用内存，效率低）

代码示例

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


public class TreeMapProblem2Demo {

	public static void main(String[] args) {

	       System.out.println(solution("aabbccddd"));	
		
	}
	
	public static StringBuilder solution(String string) {
		
		char a[]=string.toCharArray();
		
		TreeMap<Character, Integer> treeMap=new TreeMap<Character, Integer>();
		
		for (int i = 0; i < a.length; i++) {
			
                      int count=0;
                      Integer value=treeMap.get(a[i]);//
                    // System.out.println(value);
                      
                      if (value!=null) {  //33-38和30运用了代码优化
                    	  
                    	  count=value;
                    	  
					}
                      count++;
                      treeMap.put(a[i], count);
			
		}
		
		StringBuilder stringBuilder=new StringBuilder();
		Set<Map.Entry<Character, Integer>> set=treeMap.entrySet();
		Iterator<Map.Entry<Character, Integer>> iterator=set.iterator();
		
		while (iterator.hasNext()) {
			
			Map.Entry<java.lang.Character, java.lang.Integer> entry =  iterator.next();
			
			//System.out.println(entry);
             Integer integer=entry.getValue();
			Character character=entry.getKey();
			
			stringBuilder.append(character+"("+integer+")");
			
		}
		
		return stringBuilder;
		
	}

}

结果如下

2：泛型

泛型的本质是参数化的（操作的数据类型不限定于特定类型，可以根据实际需要设置不同的数据类型，以实现代码复用。），也就是所操作的数据类型被指定为一个参数。（这种参数类型可以用在类，接口，方法的创建中）

那么Java为什么要引入泛型？理由如下
1：将运行时出现的问题，转移到编译时期，方便程序员解决问题。安全，简单
2：避免了强制类型转化

注：每个泛型都定义一个原生态类型，即不带任何实际类型参数（即数据类型）的泛型名称。如points<>相对应的原生态类型就是points（原生态类型不安全）

泛型格式：通过<>来定义要操作的对象。

那么我们什 么时候定义泛型类？
当类中要操作的引用数据类型****不确定的时候，要定义泛型。

注：泛型类定义泛型，在整个类中有效。如果调用该类方法，

为了可以让不同方法操作不同类型，而且类型还不确定，可以使用泛型方法。 那么泛型类定义的对象要明确操作的具体类型，所有要操作的类型就固定了。

注：泛型只可以是代表引用类型（保存对象引用的地址栈），不可以是原始类型（保存的是实际值栈）

特殊之处：静态方法不可以访问类上定义的泛型。可以将泛型方法定义在静态方法上

3：基本数据类型对象包装类

所谓装箱，就是把基本类型用他们相对应的引用类型包起来，使他们具有对象的特质
所谓拆箱，就是把引用类型对象转换为值类型数据

下面代码会演示装箱拆箱

基本数据类型对象包装类的最常见作用：
用于基本数据类型和字符串转化。

如下做简洁介绍
1 ： 基本数据类型转化成字符串：
1.1 Integer.toString(基本数据类型值）
Integer.toString(34） //将34转换成“34
1.2 toString(int i) 静态方法
返回一个 String指定整数的 String对象。
1.3 toString(int i, int radix)
返回由第二个参数指定的基数（进制）中的第一个参数的字符串表示形式。（把十进制数转化成radix进制数）

2： 字符串转化成基本数据类型
parseInt(Sring s) 静态方法 将字符串参数解析为带符号的十进制整数。
parseInt(String s, int radix)
将字符串参数解析为第二个参数指定的基数（进制）中的有符号整数。(把radix进制数转换成十进制数）

读者应自行查阅API文档动手实践，如下代码演示

class IntegerDemo{
	
	public static void sop(String str) {
		
		System.out.println(str);
		
	}
	
}
public class PackagingClassProblem {
	
	public static void main(String[] args) {
		
		//Integer x=new Integer(4);
		Integer x=4; //自动装箱（new Integer（4））
		x=x+2;   //x进行自动拆箱，变成了int类型，和2进行加法运算，再将和进行装箱赋给x。
	
		IntegerDemo.sop("一个持有最大值的 int可以有："+Integer.MAX_VALUE);
		IntegerDemo.sop("一个持有最小值的 int可以有："+Integer.MIN_VALUE);
		
		System.out.println("字符串（按照一定的进制，比如八进制）转换成数据类型");
		IntegerDemo.sop("int i="+Integer.parseInt("123"));
		IntegerDemo.sop("int i="+Integer.parseInt("123",8));
		
		System.out.println("数据类型（按照一定的进制，比如八进制）转换成字符串");
		IntegerDemo.sop("String i="+Integer.toString(34));
		IntegerDemo.sop("String i="+Integer.toString(34,8));

	}

}

运行结果