if（i==0）{
sb.append（"["+arr[i]+","）;
}elseif（i==arr.length-1）{
sb.append（arr[i]+"]"）;
}else{
sb.append（arr[i]+","）;
}
}
returnsb.toString（）;
}
publicstaticvoidprint（T[]t）{
}
}
publicclassDemo3{
publicstaticvoidmain（String[]args）{
Integer[]arr={10,12,14,19};
MyArraystool=newMyArrays（）;
tool.reverse（arr）;
System.out.println（"数组的元素：
"+tool.toString（arr））;
MyArraystool2=newMyArrays（）;
String[]arr2={"aaa","bbb","ccc"};
tool2.reverse（arr2）;
ArrayListlist=newArrayList（）;
}
}
packagecn.itcast.genrictiry;
/*
泛型接口
泛型接口的定义格式:
interface接口名<声明自定义泛型>{
}
泛型接口要注意的事项：
1.接口上自定义的泛型的具体数据类型是在实现一个接口的时候指定的。
2.在接口上自定义的泛型如果在实现接口的时候没有指定具体的数据类型，那么默认为Object类型。
需求：
目前我实现一个接口的时候，我还不明确我目前要操作的数据类型，我要等待创建接口实现类对象的时候我才能指定泛型的具体数据类型。
如果要延长接口自定义泛型的具体数据类型，那么格式如下：
格式：
publicclassDemo4implementsDao{
}
*/
interfaceDao{
publicvoidadd（Tt）;
}
publicclassDemo4implementsDao{
publicstaticvoidmain（String[]args）{
Demo4d=newDemo4（）;
}
publicvoidadd（Tt）{
}
}
packagecn.itcast.genrictiry;
importjava.util.ArrayList;
importjava.util.Collection;
importjava.util.HashSet;
/*
泛型的上下限：
需求1：
定义一个函数可以接收接收任意类型的集合对象，要求接收的集合对象只能存储Integer或者是Integer的父类类型数据。
需求2：
定义一个函数可以接收接收任意类型的集合对象，要求接收的集合对象只能存储Number或者是Number的子类类型数据。
泛型中通配符：
？
?
superInteger:
只能存储Integer或者是Integer父类元素。
泛型的下限
?
extendsNumber：
只能存储Number或者是Number类型的子类数据。
泛型上限
*/
publicclassDemo5{
publicstaticvoidmain（String[]args）{
ArrayListlist1=newArrayList（）;
ArrayListlist2=newArrayList（）;
HashSetset=newHashSet（）;
//getData（set）;
}
//泛型的上限
publicstaticvoidgetData（Collection
extendsNumber>c）{
}
//泛型的下限
publicstaticvoidprint（Collection
superInteger>c）{
}
}
packagecn.itcast.genrictiry;
importjava.util.ArrayList;
//是老程序员写的。
jdk1.4的时候写的。
publicclassMyUtil{
publicstaticArrayListgetList（）{
returnnewArrayList（）;
}
publicstaticvoidprint（ArrayListlist）{
for（inti=0;iSystem.out.println（list.get（i））;
}
}
}
packagecn.itcast.list;
importjava.util.Enumeration;
importjava.util.Vector;
/*
集合的体系：
------------|Collection单例集合的根接口
----------------|List如果是实现了List接口的集合类，具备的特点：
有序，可重复。
-------------------|ArrayListArrayList底层是维护了一个Object数组实现的。
特点：
查询速度快，增删慢。
-------------------|LinkedListLinkedList底层是使用了链表数据结构实现的，特点：
查询速度慢，增删快。
-------------------|Vector（了解即可）底层也是维护了一个Object的数组实现的，实现与ArrayList是一样的，但是Vector是线程安全的，操作效率低。
----------------|Set如果是实现了Set接口的集合类，具备的特点：
无序，不可重复。
笔试题:
说出ArrayLsit与Vector的区别?
相同点：
ArrayList与Vector底层都是使用了Object数组实现的。
不同点：
1.ArrayList是线程不同步的，操作效率高。
Vector是线程同步的，操作效率低。
2.ArrayList是JDK1.2出现，Vector是jdk1.0的时候出现的。
*/
publicclassDemo1{
publicstaticvoidmain（String[]args）{
Vectorv=newVector（）;
//添加元素
v.addElement（"张三"）;
v.addElement（"李四"）;
v.addElement（"王五"）;
//迭代该集合
Enumeratione=v.elements（）;//获取迭代器
while（e.hasMoreElements（））{
System.out.println（e.nextElement（））;
}
}
}
packagecn.itcast.list;
importjava.util.LinkedList;
importjava.util.Random;
/*
需求：
使用LinkedList存储一副扑克牌，然后实现洗牌功能。
*/
//扑克类
classPoker{
Stringcolor;//花色
Stringnum;//点数
publicPoker（Stringcolor,Stringnum）{
super（）;
this.color=color;
this.num=num;
}
@Override
publicStringtoString（）{
return"{"+color+num+"}";
}
}
publicclassDemo2{
publicstaticvoidmain（String[]args）{
LinkedListpokers=createPoker（）;
shufflePoker（pokers）;
showPoker（pokers）;
}
//洗牌的功能
publicstaticvoidshufflePoker（LinkedListpokers）{
//创建随机数对象
Randomrandom=newRandom（）;
for（inti=0;i<100;i++）{
//随机产生两个索引值
intindex1=random.nextInt（pokers.size（））;
intindex2=random.nextInt（pokers.size（））;
//根据索引值取出两张牌，然后交换两张牌的顺序
Pokerpoker1=（Poker）pokers.get（index1）;
Pokerpoker2=（Poker）pokers.get（index2）;
pokers.set（index1,poker2）;
pokers.set（index2,poker1）;
}
}
//显示扑克牌
publicstaticvoidshowPoker（LinkedListpokers）{
for（inti=0;iSystem.out.print（pokers.get（i））;
//换行
if（i%10==9）{
System.out.println（）;
}
}
}
//生成扑克牌的方法
publicstaticLinkedListcreatePoker（）{
//该集合用于存储扑克对象。
LinkedListlist=newLinkedList（）;
//定义数组存储所有的花色与点数
String[]colors={"黑桃","红桃","梅花","方块"};
String[]nums={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
for（inti=0;ifor（intj=0;jlist.add（newPoker（colors[j],nums[i]））;
}
}
returnlist;
}
}
packagecn.itcast.list;
importjava.util.LinkedList;
classPerson{
Stringname;
intage;
publicPerson（Stringname,intage）{
super（）;
this.name=name;
this.age=age;
}
@Override
publicStringtoString（）{
return"{名字：
"+this.name+"年龄：
"+this.age+"}";
}
}
publicclassDemo3{
publicstaticvoidmain（String[]args）{
LinkedListlist=newLinkedList（）;
list.add（newPerson（"狗娃",7））;
list.add（newPerson（"狗剩",17））;
list.add（newPerson（"铁蛋",3））;
list.add（newPerson（"美美",30））;
//编写一个函数根据人的年龄及逆行排序存储。
for（inti=0;ifor（intj=i+1;j//符合条件交换位置
Personp1=（Person）list.get（i）;
Personp2=（Person）list.get（j）;
if（p1.age>p2.age）{
//交换位置
list.set（i,p2）;
list.set（j,p1）;
}
}
}
System.out.println（list）;
}
}
packagecn.itcastset;
importjava.util.HashSet;
importjava.util.Set;
/*
集合的体系：
------------|Collection单例集合的根接口
----------------|List如果是实现了List接口的集合类，具备的特点：
有序，可重复。
-------------------|ArrayListArrayList底层是维护了一个Object数组实现的。
特点：
查询速度快，增删慢。
-------------------|LinkedListLinkedList底层是使用了链表数据结构实现的，特点：
查询速度慢，增删快。
-------------------|Vector（了解即可）底层也是维护了一个Object的数组实现的，实现与ArrayList是一样的，但是Vector是线程安全的，操作效率低。
----------------|Set如果是实现了Set接口的集合类，具备的特点：
无序，不可重复。
无序：
添加元素的顺序与元素出来的顺序是不一致的。
*/
publicclassDemo1{
publicstaticvoidmain（String[]args）{
Setset=newHashSet（）;
set.add（"王五"）;
set.add（"张三"）;
set.add（"李四"）;
System.out.println（"添加成功吗？
"+set.add（"李四"））;
System.out.println（set）;
}
}
packagecn.itcastset;
importjava.util.HashSet;
importjavax.print.attribute.HashAttributeSet;
/*
集合的体系：
------------|Collection单例集合的根接口
----------------|List如果是实现了List接口的集合类，具备的特点：
有序，可重复。
-------------------|ArrayListArrayList底层是维护了一个Object数组实现的。
特点：
查询速度快，增删慢。
-------------------|LinkedListLinkedList底层是使用了链表数据结构实现的，特点：
查询速度慢，增删快。
-------------------|Vector（了解即可）底层也是维护了一个Object的数组实现的，实现与ArrayList是一样的，但是Vector是线程安全的，操作效率低。
----------------|Set如果是实现了Set接口的集合类，具备的特点：
无序，不可重复。
-------------------|HashSet底层是使用了哈希表来支持的，特点：
存取速度快.
hashSet的实现原理：
往Haset添加元素的时候，HashSet会先调用元素的hashCode方法得到元素的哈希值，
然后通过元素的哈希值经过移位等运算，就可以算出该元素在哈希表中的存储位置。
升级会员 