本文共 18354 字，大约阅读时间需要 61 分钟。

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
   
    的解释：使用泛型技术，表示这个ArrayList用来储存String对象	   * 	   * *创建一个集合容器（边框），使用Collection接口子类：ArrayList	   * 	   */	  	  	   	  ArrayList 
    
      a=new ArrayList
     
      ();   	  Collection 
      
        c=new ArrayList
       
        ();   	  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 
        
          ite=a.iterator(); while(ite.hasNext()) { // Ireator接口的方法：判断是否存在另一个可访问元素 System.out.println(ite.next()); //Ireator接口的方法：返回要访问的下一个元素 } System.out.println("ListIterator迭代器的使用"); // ListIterator 
         
           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
   
     deleteSamePerson(ArrayList
    
      person) {   		ArrayList
     
       arrayList = new ArrayList
      
       ();		Iterator
       
         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
        
          a = new ArrayList
         
          (); 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
          
            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
           
             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
   
      queue =new LinkedList
    
     ();				System.out.println("现在队列的排序顺序：");		queue.add(1);		queue.add(2);		queue.add(3);		queue.add(4);		Iterator
     
       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
      
         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
   
     stack=new LinkedList
    
     ();				System.out.println("现在栈的排列顺序");		stack.addFirst(1);		stack.addFirst(2);		stack.addFirst(3);		stack.addFirst(4);				Iterator
     
       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
      
        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
   
     a = new HashSet
    
     ();		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
     
       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
   
     {    // 该接口强制让学生具备比较性	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
    
      a = new TreeSet
     
      ();		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
      
        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
   
     a = new TreeSet
    
     (new Comparator
     
      () {   						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
      
        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
   
     a=new HashMap
    
     ();				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
     
       b=a.keySet(); //使用该Map方法：可以返回此Map集合中包含的键的Set的集合		Iterator 
      
        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
       
        		 * 地图*条目*（键值对）。 Map.entrySet方法返回地图的集合视图，其元素属于此类。 获取对映射条目的引用的唯一方法是从该集合视图的*迭代器*。 这些*Map.Entry对象仅在迭代器*间有效; 		 */		System.out.println("使用Map.Entry
        
         接口输出该哈希表键队值"); Set
         
          
           > set=a.entrySet(); Iterator
           
            
             > iterator=set.iterator(); while (iterator.hasNext()) { Map.Entry
             
               aEntry=iterator.next(); System.out.println("键"+aEntry.getKey()+"---"+"值"+aEntry.getValue()); } System.out.println("返回此地图中包含的值的Collection视图:"); Collection
              
                collection=a.values(); System.out.println(collection); }}
              
             
            
           
          
         
        
       
      
     
    
   

运行结果如下

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

步骤：1：描述学生类

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

代码如下

class Students implements Comparable
   
     {   	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()
    
      hashMap=new HashMap
     
      ();				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
      
       接口输出该哈希表键队值");		Set
       
        
         > set=hashMap.entrySet(); Iterator
         
          
           > iterator=set.iterator(); while (iterator.hasNext()) { Map.Entry
           
             entry = iterator .next(); System.out.println(entry.getKey()+" ..."+entry.getValue()); } System.out.println("使用set接口输出该哈希表键队值"); Set
            
              set2 =hashMap.keySet(); Iterator
             
               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
   
     treeMap=new TreeMap
    
     ();				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
     
      
       > set=treeMap.entrySet();		Iterator
       
        
         > iterator=set.iterator(); while (iterator.hasNext()) { Map.Entry
         
           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));	}}

运行结果