黑马程序员_Java 集合_01

最新推荐文章于 2015-09-19 13:03:00 发布

也许依然

最新推荐文章于 2015-09-19 13:03:00 发布

阅读量396

点赞数

本文链接：https://blog.csdn.net/u013940467/article/details/22165591

版权

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

JAVA_API

String类

字符串是一个特殊的对象。

字符串一旦初始化就不可以被改变。

String类适合用于描述字符串事物

那么他就提供了多少个方法对字符串进行操作

字符串常见的操作

1，获取

1.1 字符创中包含的字符数，也就是字符串的长度

int length()：获取长度

1.2 根据位置获取位置上某个字符

char charAt(int index):

1.3 根据字符获取该字符在字符串中的位置

int indexOf( int ch ）返回的是ch在字符串中第一次出现的位置

int indexOf( int ch, int fromIndex ) 从fromIndex指定位置开始，或取ch在字符串中出现的位置

int indexOf( String str）返回的是str在字符串中第一次出现的位置

int indexOf( String str, int fromIndex ) 从fromIndex指定位置开始，或取str在字符串中出现的位置

2 ，获取

2.1 字符串中是否包含某一个字符串

boolean contains(str);

特殊之处：indexOf(str)：可以索引str第一次出现的位置，如果返回-1，表示str不在该字符串中存在

if(str.indexOf("aa")!=-1)

该方法既可以判断，又可以获取出现的位置

2.2 字符串中是否有内容

boolean isEmpty(); 判断长度是否为零："" null

2.3 字符串是否以指定内容开头

boolean startsWith(str);

2.4 字符串是否以指定位置结尾

boolean endsWith(str);

2.5 判断字符串内容是否相同。复习了Object类中的equals方法

boolean equals(str);

2.6 判断内容是否相同，并忽略大小写

boolean equalsIgnoreCase(str);

3，转换

3.1 将字符数组转换成字符串

构造函数：String（char[])

String (char[], offset, count)将字符数组中的一部分转换成字符串

静态方法：

static String copyValueOf(char[]);

static String copyValueOf(char[] data, int offset , int count);

3.2 将字符串转换成字符数组

char[] toCharArray()；

3.3 将字节数组转换成字符串

String（char[])

String (char[], offset, count)将字符数组中的一部分转换成字符串

3.4 将字符串转成字节数组

byte[] getBytes();

3.5 将基本数据类型转换成字符串

String valueOf(int);

String valueOf(double);

3+""; //String valueOf(3);

特殊：字符串和字节数组在转换过程中，是可以指定编码表的

4，替换

String replace(oldchar , newchar);

5，切割

String[] split(regex);

6，字串。获取字符串中的一部分

String substring(begin);

String substring(begin，end);

7，转换，去除空格，比较

7.1 将字符串转换成大写或小写

String toUppercase();

String toLowercase();

7.2 将字符串两端的多个空格去掉

String trim();

7.3 对两个字符串进行自然顺序的比较

int copmpareTo(String);

字符串操作演示

package StringMethodDemo;

class StringMethodDemo
{
	public static void method_7()
	{
		String s = "   Hello Java  ";
		sop(s.toUpperCase());
		sop(s.toLowerCase());
		sop(s.trim());

		String s1 = "aef";
		String s2 = "aaa";
		sop(s1.compareTo(s2));
	}

	//求字串的函数
	public static void method_substring()
	{
		String s = "abcdef";
		
		sop(s.substring(2));//从指定位置到结尾
		sop(s.substring(2,4));	//包含头，不包含尾
	}
	
	//字符串切割的函数
	public static void method_split()
	{
		String s = "zhangsanxxlisixxwangwu";
		String[] arr = s.split("xx");	//用xx作为标记来切割
		for( int x=0; x<arr.length; x++)
		{
			sop(arr[x]);
		}
	}

	//字符串替换的函数
	public static void method_replace()
	{
		String s = "hello java";
		//String s1 = s.replace('a','n');//如果替换的字符不存在，返回的是原字符串
		String s1 = s.replace("java","world");	//转换后产生了一个新字符串
		sop("s="+s);
		sop("s1="+s1);
	}	

	//字符串转换的函数
	public static void method_trans()
	{
		char[] arr = {'a','b','c','d','e','f'};
		String s = new String(arr);	//使用构造函数转换
		sop("s= "+s);

		String s1 = "abcsdssalsad";
		char[] chs = s1.toCharArray();	//将字符串s1转换成字符数组
		
		//循环打印字符数组中的每个元素
		for( int x=0; x<chs.length; x++)
		{
			sop("chs="+chs[x]);
		}
	}
	
	//字符串判断的函数
	public static void method_is()
	{
		String str = "ArrayDemo.java";	
		sop(str.startsWith("Array")); //判断文件是否是Array单词开头
		sop(str.endsWith("java"));		//判断文件是否是.java文件
		sop(str.contains("Demo"));		//判断文件是否包含Demo
	}	

	//字符串获取函数
	public static void method_get()
	{
		String str = "abcdaef";	 //定义一个字符串
		sop(str.length());		//打印字符串的长度
		
		//当访问到字符串中不存在的下标时，会出现StringIndexOutOfBoundException

		sop(str.charAt(4));		//根据索引获取字符
		
		sop(str.indexOf('m',3));//根据字符获取索引,如果没有找到返回-1
		
		sop(str.lastIndexOf("a"));//反向索引一个字符串出现的位置
		
	}

	public static void main(String[] args)
	{
		method_get();
		method_is();
		method_trans();
		method_replace();
		method_split();
		method_substring();
		method_7();
		
		/*
		String s1 = "abc";
		String s2 = new String("abc");
		String s3 = "abc";

		System.out.println(s1==s2);
		System.out.println(s1==s3);
		*/
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

字符串的练习：

1，模拟一个trim方法，去除字符串两端的空格

思路：

1 判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止

结尾处判断空格也是如此

2 当开始和结尾都判断不是空格时，就是要获取的字符串

2，将一个字符串进行反转。将字符串指定的部分进行反转

思路：

1 曾经学习过对数组的元素进行反转

2 将字符串变成数组，对数组反转

3 将反转后的数组变成字符串

4 只要将被反转的部分开始和结束的位置作为参数传递即可

3，获取一个字符串在另一个字符串中出现的次数

"dsjdooaddddooisqoo"

思路：

1 定义个计数器

2 获取oo第一次出现的位置

3 从第一次出现位置后剩余的字符串中继续获取oo出现的位置

每获取一次就计数一次

4 当获取不到时，计数完成

4，获取两个字符串中最大相同字串。第一个动作：将短的那个串进行长度依次递减的字串打印

思路：

1 将短的那个字串按照长度递减的方式获取到

2 将每获取到的字串去长串中判断是否包含

如果包含，已经找到

代码演示：

package StringTest;

class StringTest
{
	public static void sop(String str)
	{
		System.out.println(str);
	}
	
	public static void main(String[] args)
	{
		String s = "    abc  def   ";
		sop("("+s+")");
		//s = my_trim(s);
		//sop("("+s+")");
		sop("("+reverseString(s,6,9)+")");
	
		String str = "dsjdooaddddooisqoo";
		sop("count "+getSubCount_2(str,"oo"));
		
		String s1 = "shiciahellosdasdad";
		String s2 = "sjoahellosa";
		sop(getMaxSubString(s1,s2));


	}

	//练习一：去除字符串两端的空格
	public static String my_trim(String str)
	{
		//定义判断首尾空格的角标
		int start = 0 , end = str.length()-1;
		while(start<=end && str.charAt(start)==' ')
			start++;
		while(start<=end && str.charAt(end)==' ')
			end--;
		return str.substring(start,end+1);
	}


	//练习二：将字符串反转
	public static String reverseString(String str, int start, int end)
	{
		//将字符串转换成字符数组
		char[] chs = str.toCharArray();

		//反转数组
		reverse(chs,start,end);

		//数组变成字符串
		return new String(chs);
	}
	
	
	public static String reverseString(String str)
	{
		return reverseString(str,0,str.length());
	}
	
	private static void reverse(char[] arr,int x, int y)	//字符数组反转函数
	{
		for( int start=x,end=y-1; start<end; start++,end--)	//一般包含头不包含尾，y-1
		{
			swap(arr,start,end);	
		}	
	}
	
	private static void swap(char[] arr, int x, int y)	//交换函数
	{
		char temp = arr[x];
		arr[x] = arr[y];
		arr[y] = temp;
	}

	//练习三
	public static int getSubCount_1(String str,String key)
	{
		int count = 0;	//定义计数器
		int index = 0;	//记录key第一次出现的位置
		while((index=str.indexOf(key))!=-1)
		{
			sop("str= "+str);
			str = str.substring(index+key.length());	//依次返回key后边的子串
			count++;	//计数器自增
		}
		return count;
	}
	
	//练习三：方式二
	public static int getSubCount_2(String str,String key)
	{
		int count = 0;
		int index = 0;
		while((index=str.indexOf(key,index))!=-1)//从指定位置开始判断
		{
			index = index+key.length();
			count++;
		}
		return count;
	}
	//练习四
	public static String getMaxSubString(String s1,String s2)
	{
		//求短的字符串
		String max="",min="";
		max = (s1.length()>s2.length())? s1:s2;
		min = (max==s1)? s2 : s1;
		
		sop("max= "+max+" min= "+min);

		for(int x=0; x<min.length(); x++)
			for(int y=0,z=min.length()-x; z!=min.length()+1; y++,z++)
			{
				String temp = min.substring(y,z);
				//长的字符串中是否包含最大字串
				if(max.contains(temp))// if(max.indexOf(temp)!=-1)
					return temp;
			} 
			return "";
	}

}

StringBuffer

是一个容器

特点：

1 而且长度是可变化的

2 可以直接操作多个数据类型

3 最终会通过toString()方法变成字符串

C create U update R read D delete

1，存储

StringBuffer append() :将制定数据作为参数添加到已有数据结尾处

StringBuffer insert(index,数据) :可以将数据插入到制定index位置

2，删除

StringBuffer delete(start,end)删除缓冲区中的数据，包含start，不包含end

StringBuffer deleteCharAt(index)删除指定位置的字符

3，获取

4，修改

StringBuffer replace(start,end,String);

StringBuffer setCharAt(int index,char ch);

5，反转

StringBuffer reverse();

6，将缓冲区中指定数据存储到制定数组中

void getchas(int srcBegin, int srcEnd, char[] dst, int dstBegin);

JDK 1.5 版本之后出现了StringBuilder

StringBuffer是线程同步

StringBuilder是线程不同步。//不用判断锁，单线程运行比较快捷

以后开发，建议使用StringBuilder

升级三个因素：

1，提高效率

2，简化书写

3，提高安全性

代码演示：

package StringBuffer;

class StringBufferDemo
{	
	public static void main(String[] args)
	{
		method_del();
		method_update();

		StringBuffer sb = new StringBuffer("abcdef");
		char[] chs = new char[4];
		sb.getChars(1,4,chs,1);		//将字符串1~3的字符复制到chs中从1开始的位置
		for(int x=0; x<chs.length; x++)
		{
			//依次打印字符数组chs中的字符
			sop("chs["+x+"]="+chs[x]);
		}
	}
	
	//字符串替换的函数
	public static void method_update()
	{
		StringBuffer sb = new StringBuffer("abcde");
		sb.replace(1,4,"java");	//将从下标为1到4(不包含)的字符替换为"java"
		sb.setCharAt(2,'k');	//将索引为2处的字符替换为k
		sop(sb.toString());		//打印字符串

		
	}
	
	public static void method_del()
	{
		StringBuffer sb = new StringBuffer("abcde");
		sb.delete(1,3);				//移除从索引1开始到索引(3-1)处的字符
		sop(sb.toString());
		sb.delete(0,sb.length());	//清空缓冲区
		sop(sb.toString());
	}

	public static void method_add()
	{
		StringBuffer sb = new StringBuffer();	//定义一个缓冲区

		sb.append("abc").append(true);//不断地在末尾添加数据，返回的是StringBuffer对象

		sop(sb.toString());
	
		sb.insert(1,"qq");	//在指定位置插入数据
		sop(sb.toString());
	}
	
	
	public static void sop(String str)
	{
		System.out.println(str);
	}
}

基本数据类型对象包装类

byte Byte

short short

int Integer

long Long

boolean Boolean

duble Double

char Character

基本数据类型对象包装类最常见作用：

就是用于基本数据类型和字符串类型之间做转换

基本数据类型转成字符串

基本数据类型+""

基本数据类型.toString(基本数据类型);

字符串转成基本数据类型

xxx a = Xxx.parseXxx(string);

int a = Integer.parseInt("123");

double d = Double.parseDouble("12.34");

boolean b = Boolean.parseBoolean("true");

十进制转换成其他进制

toBinaryString();

toHexString();

toOctalString();

其他进制转成十进制

parseInt(string s, int radix);

代码演示：

package IntegerDemo;

class IntegerDemo
{
	public static void sop(String str)
	{
		System.out.println(str);
	}
	
	public static void main(String[] args)
	{
		//整数类型的最大值
		sop("int max :"+Integer.MAX_VALUE);

		//将一个字符串转成整数
		int num = Integer.parseInt("123");
		long x= Long.parseLong("123");

		sop("num="+(num+4));

		sop(Integer.toBinaryString(-6));	//将十进制转换成二进制
		sop(Integer.toHexString(-6));		//将十进制转换成十六进制

		int y = Integer.parseInt("110",2);	//将二进制转换成十进制
		sop("y = "+y);

		Integer x = 4;	//自动装箱
		x = x+4;		//进行自动拆箱，将x变成Int型，和4进行运算，再自动装箱
	}
}

集合

List

Collection

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

|--ArrayList: 底层的数据结构使用的是数组结构。线程不同步

|--LinkedList: 底层的数据结构使用的是链表结构

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

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

List：

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

增

add(index,element);

addAll(index,Collection);

删

remove(index);

改

set(index,element);

查

get(indx)

subList(from,to);

listIterator

ListIterator

List集合特有的迭代器。ListIterator是Iterator的子接口

在迭代时，不可以通过集合对象的方法操作集合中的元素

因为会发生ConcurrentModificationException异常

所以，在迭代时，只能用迭代器的方法操作元素，可是Iterator的方法是有限的

只能对元素进行判断、取出、删除的操作

如果想要其他的操作茹添加、修改等，就需要使用其子接口listIterator

该接口只能通过List集合的ListIterator方法获取

代码演示：

package ListDemo;

import java.util.*;

class ListDemo
{
	public static void main(String[] args)
	{
		ArrayList al = new ArrayList();
		
		al.add("java01");
		al.add("java02");
		al.add("java03");

		//演示列表迭代器
		ListIterator li = al.listIterator();
		
		while(li.hasNext())
		{
			Object obj = li.next();
			
			if(obj.equals("java02"))
				li.set("java006");
		}
		sop("hasNext:"+li.hasNext());

		//逆向迭代列表，判断集合中是否还有元素
		sop("hasPrevious:"+li.hasPrevious());


		/*
		//在迭代或删除过程中，准备添加或删除元素
		Iterator it = al.iterator();
		while(it.hasNext())
		{
			Object obj = it.next();
			if(obj.equals("java01"))
				//al.add("java008");	//在迭代器中使用List的方法，会出现并发修改异常
				it.remove();//将java02的引用从集合中删除了
			
			sop("obj="+obj);
		}
		*/
		sop(al);
	}
	
	public static void method()
	{
		ArrayList al = new ArrayList();
		
		//添加元素
		al.add("java01");
		al.add("java02");
		al.add("java03");

		sop("原集合是:"+al);

		//在指定位置添加元素
		al.add(1,"java09");
		sop(al);

		//删除指定位置的元素
		al.remove(2);
		
		//修改元素
		al.set(1,"java007");
		sop(al);

		//通过下标获取元素
		sop("get(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(it.next());
		}
		
		//通过indexOf获取元素的位置
		sop("index="+al.indexOf("java02"));
		
		//获取子列表
		List sub = al.subList(1,3);
		sop("sub="+sub);
	}

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

LinkedList：特有方法

addFist();

addLast();

getFist();

getLast();

获取元素，但不删除元素

removeFist();

removeLast();

获取元素，但元素被删除,如果集合中没有元素，会出现NoSuchElementException异常

在JDK1.6出现了替代方法

offerFirst();

offerLast();

peekFirst();

peekLast();

获取元素，但不删除元素，如果没有元素，返回null

pollFirst();

pollLast();

获取元素，但是元素被删除。如果集合中没有元素，会返回null

代码演示：

class LinkedListDemo
{
	public static void main(String[] args)
	{
		LinkedList link = new LinkedList();
		
		//依次在集合开始位置添加元素
		link.addFirst("java01");
		link.addFirst("java02");
		link.addFirst("java03");
		link.addFirst("java04");

		sop(link);

		sop(link.getFirst());	//获取集合中的第一个元素
		sop(link.getLast());	//获取集合中的最后一个元素

		sop("size="+link.size());
		
		sop(link.removeFirst());	//获取集合第一个元素，并删除
		sop(link);
	
		while(!link.isEmpty())
		{
			sop(link.removeLast());
		}
	}

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

使用LinkedList模拟一个线性的数据结构：

package LinkedListTest;
/*
使用LinkedList模拟一个堆栈或者队列数据结构
*/
import java.util.*;

class Queue
{
	private LinkedList link;
	Queue()
	{
		link = new LinkedList();
	}
	
	//添加元素
	public void my_add(Object obj)
	{
		//在link开始位置添加元素
		link.addFirst(obj);
	}

	//取出元素
	public Object my_get()
	{
		return link.removeLast();
	}
	
	//判断链表是否为空
	public boolean isNull()
	{
		return link.isEmpty();
	}
}

class LinkedListTest
{
	public static void main(String[] args)
	{
		Queue q = new Queue();
		
		q.my_add("java01");
		q.my_add("java02");
		q.my_add("java03");
		q.my_add("java04");

		while(!q.isNull())
		{
			System.out.println(q.my_get());
		}		
	}
}

CollectionDemo

1，add()方法的参数是Object类型，以便于接收任意对象

2，集合中存储的都是对象的引用（地址）

什么是迭代器呢？

其实就是集合取出元素的方式

把取出的方式定义在集合的内部

这样取出方式就可以直接访问集合内容的元素

而每一个容器的数据结构不同

所以取出的动作和细节也不一样但是都有共性的内容，判断和取出

可以将其共性抽取

那么这些内部类都符合一个规则

该规则是Iterator

如何获取集合的取出对象呢？

通过一个对外提供的方法 iterator();

代码演示：

package CollectionDemo;

import java.util.*;


class CollectionDemo
{
	public static void main(String[] args)
	{
		method_2();
		base_method();
		method_get();
	}
	
	public static void method_get()
	{
		ArrayList al = new ArrayList();

		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
	
		Iterator it = al.iterator();	//获取迭代器，用于取出集合中的元素 
		
		while(it.hasNext())
		{	
			sop(it.next());
		}
		
	}
		
	public static void method_2()
	{
		//创建一个容器，使用Collection接口的子类，ArrayList
		ArrayList al1 = new ArrayList();

		al1.add("java01");
		al1.add("java02");
		al1.add("java03");
		al1.add("java04");

		ArrayList al2 = new ArrayList();

		al2.add("java01");
		al2.add("java02");
		al2.add("java05");
		al2.add("java06");	

		//在al1中保留只包含和al2中相同的元素
		al1.retainAll(al2);
		//al1.removeAll(al2); //删除和al中元素相同的元素

		sop("al1:"+al1);
		sop("al2:"+al2);
	}

	public static void base_method()
	{
		//创建一个容器，使用Collection接口的子类，ArrayList
		ArrayList al = new ArrayList();

		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");

		sop(al);
		
		//删除元素
		//al.remove("java02");
		//al.clear();	//清空集合

		//判断元素
		sop("java03是否存在"+al.contains("java03"));
		sop("集合是否为空? "+al.isEmpty());	

		//获取个数，集合长度
		sop("size:"+al.size());

		//打印改变后的集合
		sop(al);
	}

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

ArrayList练习

取出ArrayList集合中的重复元素

将自定义对象作为元素存储到ArrayList集合中，并去除重复元素

思路：

1，对人描述，将数据封装进入对象

2，定义容器，将人存入

3，取出

List集合判断元素是否相同，依据元素的equals方法

代码演示：

package ArrayListTest;

import java.util.*;

class Person
{
	//定义名字
	private String name;
	
	//定义年龄
	private int age;

	//构造函数初始化
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}

	//复写equals方法
	public boolean equals(Object obj)
	{
		//如果传入的对象不是Person对象
		if(!(obj instanceof Person))
			return false;
		Person p = (Person)obj;

		//同姓名同年龄视为同一个元素
		return this.name.equals(p.name) && this.age==p.age;
	}
	//获取姓名
	public String getName()
	{
		return name;
	}
	//获取年龄
	public int getAge()
	{
		return age;
	}
}

class ArrayListTest
{
	public static void main(String[] args)
	{
		method_2();
	}
	
	public static void method_2()
	{
		
		ArrayList al = new ArrayList();
		
		//在ArrayList中存入Person对象
		al.add(new Person("lisi01",30));
		al.add(new Person("lisi02",32));
		al.add(new Person("lisi03",33));
		al.add(new Person("lisi04",35));
		al.add(new Person("lisi05",38));

		//定义一个迭代器
		Iterator it = al.iterator();

		while(it.hasNext())		//在循环中next()只能调用一次就要hasNext()判断一次
		{
			//Object obj = it.next();
			//Person p = (Person)obj;
		
			//Object中没有getName()和getAge()方法，必须向下转型
			Person p = (Person)it.next();
			sop(p.getName()+"  "+p.getAge());
		}
	}	

	public static void method_1()
	{
		ArrayList al = new ArrayList();
		
		al.add("java01");
		al.add("java02");
		al.add("java01");
		al.add("java02");
		al.add("java01");
		al.add("java03");

		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();
			
			//如果新容器中不包含obj，加obj添加到新容器
			if(!newAl.contains(obj))
				newAl.add(obj);
		}
		return newAl;
	}

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

Vector

枚举就是Vector特有的取出方式

发现Enumeration和和Iterator很像

因为枚举的名称以及方法的名称都过长

所以被迭代器取代了

代码演示：

package VectorDemo;

import java.util.*;

class VectorDemo
{
	public static void main(String[] args)
	{
		Vector v = new Vector();
		
		v.add("java01");
		v.add("java02");
		v.add("java03");
		v.add("java04");
		
		//其实枚举和迭代是一样的
		Enumeration en = v.elements();
		
		while(en.hasMoreElements())
		{
			//取出下一个元素
			System.out.println(en.nextElement());
		}		
		
	}
}

Set

|--Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复

|--HashSet:底层的数据结构是哈希表

HashSet是如何保证元素唯一性的呢

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

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

|--TreeSet

Set 集合的功能和Collection是一样的

HashDemo代码演示：

package HashSetDemo;

import java.util.*;

class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	//覆盖hashCode方法
	public int hashCode()
	{
		System.out.println(this.name+"....code");
		return name.hashCode()+age()*39;
	}
	//覆盖equals方法
	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;
	}
}

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

	public static void main(String[] args)
	{
		//创建一个HashSet集合对象
		HashSet hs = new HashSet();
	
		//在集合中添加元素
		hs.add("java01");	
		hs.add("java02");
		hs.add("java03");
		hs.add("java04");
		
		//Set集合只有一种取出方式，迭代器
		Iterator it = hs.iterator();

		while(it.hasNext())
		{
			sop(it.next());
		}
	}
}

也许依然

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员_Java 集合_01

------- android培训、java培训、期待与您交流！ ----------JAVA_APIString类字符串是一个特殊的对象。字符串一旦初始化就不可以被改变。 String类适合用于描述字符串事物那么他就提供了多少个方法对字符串进行操作字符串常见的操作 1，获取 1.1 字符创中包含的字符数，也就是字符串的长度
复制链接

扫一扫