milimili
- 浏览: 3161 次
-
文章分类
最新评论
第一讲 泛型（Generic）
一、概述
1、JDK1.5版本以后出现的新特性。用于解决安全问题，是一个类型安全机制。
2、JDK1.5的集合类希望在定义集合时，明确表明你要向集合中装入那种类型的元素，无法加入指定类型以外的数据。
泛型的出现，1方面将ClassCastException的隐患，转移到了编译时期。方便于程序员解决问题。让运行时问题减少，安全。
2同时，避免了强制转换麻烦。
泛型应用示例：
二、泛型类
什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，
早期定义Object来完成扩展。
现在定义泛型来完成扩展。
示例：
三、泛型方法
泛型定义在类上，则在整个类中有效。那么该类对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型，而且类型还不确定。
那么可以将泛型定义在方法上。
四、泛型定义在接口上
示例：
五、泛型的限定
1.? 通配符。也可以理解为占位符。
2.泛型的限定；
？ extends E: 可以接收E类型或者E的子类型。上限。
3. ？ super E: 可以接收E类型或者E的父类型。下限
第二讲 Collections
一、概述
Collections是对集合框架的一个工具类。它里边的方法都是静态的，不需要创建对象。并未封装特有数据。
在Collections工具类中大部分方法是用于对List集合进行操作的，如比较，二分查找，随机排序等。
二、常见操作
1、查找
T max(Collection<? extends T> coll);//根据集合的自然顺序，获取coll集合中的最大元素
T max(Collection<? extends T> coll,Comparator<? super T> comp);//根据指定比较器comp的顺序，获取coll集合中的最大元素
int binarySearch(Lsit<? extends Comparable<? super T>> list,Tkey);//二分法搜索list集合中的指定对象
2、替换
void fill(List<? super T> list, T obj);//将list集合中的全部元素替换成指定对象obj
boolean replaceAll(List<T> lsit,T oldVal,T newVal);//用newVal替换集合中的oldVal值
void swap(Listlist,int i,int j);/在指定列表的指定位置处交换元素
3排序：
void shuffle(List<?> list);//使用默认随机源对list集合中的元素进行随机排序
void sort(Lsit<T> list);//根据自然顺序对list集合中的元素进行排序
void sort(List<T> lsit,Comparator<? super T> c);//根据指定比较器c的排序方式对list集合进行排序
4、反转
reverse(List<?> list);//反转list集合中元素的顺序
Comparator reverseOrder();//返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序
Comparator reverseOrder(Comparator<T> cmp);//返回一个比较器，强行逆转了指定比较器的顺序
5、同步的集合
List<T> synchronizedList(List<T> list);//返回支持的同步（线程安全的）List集合
Map<K,V> synchronizedList(Map<K,V> m);//返回支持的同步（线程安全的）Map集合
三、Collections和Collection的区别
Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。
它有两个常用的子接口：
List：对元素都有定义索引。有序的。可以重复元素。
Set：不可以重复元素。无序
Collections是集合框架中的一个工具类。该类中的方法都是静态的。提供的方法中有可以对list集合进行排序，二分查找等方法
通常常用的集合都是线程不安全的。因为要提高效率。如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。
第三讲 Arrays
一、概述
Arrays是用于操作数组的工具类。里边的方法也全是静态的。不需要创建对象。
把数组变成List集合的好处：可以使用集合的思想和方法来操作数组中的元素。如：contains，get，indexOf，subList等方法。
二、常见方法
1、Lsit<T> asList(T... a);//将数组转换为集合
注意：
a、将数组转换成集合，不可使用集合的增删方法，因为数组的长度是固定的。如果进行增删操作，通过编译，但运行时会因产生UnsupportedOperationException异常而中断运行。
b、如果数组中的元素都是对象，则变成集合时，数组中的元素就直接转为集合中的元素。
c、如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
2、binarySearch()：二分查找方法，fill()：替换方法，sort()：排序方法等
特点：可对数组元素进行相应操作，可以接受除boolean之外的其他各种基本数据类型及有序的引用类型数组的参数，且还可以对指定元素的范围，并可根据指定比较器进行相应的操作。
如：sort(T[]a,Comparator<? super T> c)
fill(int[]a,int from,int to)等
3、String toString();//可以接收各种数组类型参数，并返回指定数组内容的字符串表现形式。
2. 增强for循环
高级for循环
格式：
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
{ }
对集合进行遍历。
只能获取集合元素。但是不能对集合进行操作。
迭代器除了遍历，还可以进行remove集合中元素的动作。
如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。
传统for和高级for有什么区别呢？
高级for有一个局限性。必须有被遍历的目标。
建议在遍历数组的时候，还是希望是用传统for。因为传统for可以定义脚标。
一、概述
1、JDK1.5版本以后出现的新特性。用于解决安全问题，是一个类型安全机制。
2、JDK1.5的集合类希望在定义集合时，明确表明你要向集合中装入那种类型的元素，无法加入指定类型以外的数据。
/*
在JDK1.5之前，集合定义时不能预集合将要存入的元素是那种类型，只要是引用类型都能add。
这导致两方面问题，1.取出集合后需要强转；2.程序运行时可能导致java.lang.ClassCastException异常导致程序挂掉；
如下：
*/
class GenericDemo
{
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add("abc01");
al.add("abc0991");
al.add("abc014");
al.add(4);//al.add(new Integer(4));
Iterator it = al.iterator();
while(it.hasNext())
{
String s = (String)it.next();
System.out.println(s+":"+s.length());
}
}
}
泛型的出现，1方面将ClassCastException的隐患，转移到了编译时期。方便于程序员解决问题。让运行时问题减少，安全。
2同时，避免了强制转换麻烦。
class GenericDemo
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc01");
al.add("abc0991");
al.add("abc014");
al.add(4);//al.add(new Integer(4));
Iterator<String> it = al.iterator();
while(it.hasNext())
{
String s = it.next();
System.out.println(s+":"+s.length());
}
}
}
泛型应用示例：
/*
TreeSet集合。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。
定义一个TreeSet集合，使用泛型。向集合中存入字符串，按字符串长度排序，如果字符串长度相同再按字符大小排序 */
import java.util.*;
class GenericDemo2
{
public static void main(String[] args){
TreeSet<String> set = new TreeSet<String>(new LenComparator());
set.add("abcdefabcd");
set.add("hello");
set.add("nihaom");
set.add("aaa");
set.add("aab");
Iterator<String> it = set.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
}
}
class LenComparator implements Comparator<String>{//实现public interface Comparator<T>接口，此接口支持泛型
public int compare(String s1, String s2){
int num = new Integer(s2.length()).compareTo(new Integer(s1.length()));
if(num==0)
return s2.compareTo(s1);
return num;
}
}
二、泛型类
什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，
早期定义Object来完成扩展。
现在定义泛型来完成扩展。
示例：
/*
//最初做法，对每一种实体类分别定义工具类，通用性差
class Tool
{
private Worker w;
public void setWorker(Worker w)
{
this.w = w;
}
public Worker getWorker()
{
return w;
}
}
*/
class Worker
{
}
class Student
{
}
//泛型前做法。//需要强转，可能产生ClassCastException
class Tool
{
private Object obj;
public void put(Object obj)
{
this.obj = obj;
}
public Object get()
{
return obj;
}
}
//泛型类。
/*
什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，
早期定义Object来完成扩展。
现在定义泛型来完成扩展。
*/
class Utils<QQ>
{
private QQ q;
public void put(QQ q)
{
this.q = q;
}
public QQ get()
{
return q;
}
}
class GenericDemo3
{
public static void main(String[] args)
{
Utils<Worker> u = new Utils<Worker>();
u.put(new Worker());
Worker w = u.get();;
/*
Tool t = new Tool();
t.put(new Student());
Worker w = (Worker)t.get();
*/
}
}
三、泛型方法
泛型定义在类上，则在整个类中有效。那么该类对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
//泛型定义在类上，则在整个类中有效。那么该类对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
class Tool<T>{
public void show(T t){
System.out.println(t);
}
public void print(T t){
System.out.println(t);
}
}
public class Gen{
public static void main(String[] args){
Tool<String> tool = new Tool<String>();
tool.show("abc");
// tool.print(new Integer(12));//编译报错：错误: 无法将类 Tool<T>中的方法 show应用到给定类型;
}
}
为了让不同方法可以操作不同类型，而且类型还不确定。
那么可以将泛型定义在方法上。
//泛型定义在类上，则在整个类中有效。那么该类对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
class Tool{
public <T> void show(T t){
System.out.println(t);
}
public <Q> void print(Q q){
System.out.println(q);
}
}
public class Gen{
public static void main(String[] args){
Tool tool = new Tool();
tool.show("abc");
tool.print(new Integer(12));
}
}
//本例中Tool类上定义了泛型，Tool类中的print方法也定义了泛型，则main方法调用print时，可以传入任意引用类型
class Tool <T> {
public void show(T t){
System.out.println(t);
}
public <Q> void print(Q q){
System.out.println(q);
}
}
public class Gen{
public static void main(String[] args){
Tool tool = new Tool();
tool.show("abc");
tool.print(new Integer(12));
tool.print("def");
}
}
/*
特殊之处：
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
*/
class Tool <T> {
public void show(T t){
System.out.println(t);
}
public <Q> void print(Q q){
System.out.println(q);
}
public static void staticmethod(T t){
System.out.println(t);
}
}
public class Gen{
public static void main(String[] args){
Tool tool = new Tool();
tool.show("abc");
tool.print(new Integer(12));
tool.print("def");
tool.staticmethod(" 无法从静态上下文中引用非静态 类型变量 T");
}
}
/*
特殊之处：
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
*/
class Tool <T> {
public void show(T t){
System.out.println(t);
}
public <Q> void print(Q q){
System.out.println(q);
}
public static <W> void staticmethod(W w){
System.out.println(w);
}
}
public class Gen{
public static void main(String[] args){
Tool tool = new Tool();
tool.show("abc");
tool.print(new Integer(12));
tool.print("def");
tool.staticmethod(" 静态方法操作的应用数据类型不确定，可以将泛型定义在方法上");
}
}
四、泛型定义在接口上
示例：
//泛型定义在接口上
interface MyInterface<T>{
void show(T t);
}
class MyClass implements MyInterface<String>{
public void show(String s){
System.out.println(s);
}
}
class Gen{
public static void main(String[] args){
MyClass mc = new MyClass();
mc.show("hello");
}
}
//泛型定义在接口上
interface MyInterface<T>{
void show(T t);
}
class MyClass<T> implements MyInterface<T>{
public void show(T t){
System.out.println(t);
}
}
class Gen{
public static void main(String[] args){
MyClass<String> mc = new MyClass<String>();
mc.show("hello");
}
}
五、泛型的限定
1.? 通配符。也可以理解为占位符。
//? 通配符。也可以理解为占位符。
import java.util.*;
class Gen{
public static void main(String[] args){
ArrayList<String> al1 = new ArrayList<String>();
al1.add("abc");
al1.add("def");
al1.add("ghk");
ArrayList<Integer> al2 = new ArrayList<Integer>();
al2.add(1);
al2.add(2);
al2.add(3);
printColl(al1);
printColl(al2);
}
public static void printColl(ArrayList<?> al){
Iterator<?> it = al.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
//?通配符，此外也可以在静态方法上定义个<T>来实现上例的功能
import java.util.*;
class Gen{
public static void main(String[] args){
ArrayList<String> al1 = new ArrayList<String>();
al1.add("abc");
al1.add("def");
al1.add("ghk");
ArrayList<Integer> al2 = new ArrayList<Integer>();
al2.add(1);
al2.add(2);
al2.add(3);
printColl(al1);
printColl(al2);
}
public static <T> void printColl(ArrayList<T> al){
Iterator<T> it = al.iterator();
while(it.hasNext()){
T t = it.next();
System.out.println(t);
}
}
}
2.泛型的限定；
？ extends E: 可以接收E类型或者E的子类型。上限。
import java.util.*;
class Gen{
public static void main(String[] args){
ArrayList<Person> al1 = new ArrayList<Person>();
al1.add(new Person("zhangsan"));
al1.add(new Person("lisi"));
al1.add(new Person("wangwu"));
ArrayList<Student> al2 = new ArrayList<Student>();
al1.add(new Student("xuesheng1"));
al1.add(new Student("xuesheng2"));
al1.add(new Student("xuesheng3"));
printColl(al1);
printColl(al2);
}
public static void printColl(ArrayList<Person> al){
// 此处相当于ArrayList<Person> al = ArrayList<Student> al2
// 错误提示：
// 需要: ArrayList<Person>
// 找到: ArrayList<Student>
// 原因: 无法通过方法调用转换将实际参数ArrayList<Student>转换为ArrayList<Person>
Iterator<Person> it = al.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
class Person{
private String name;
Person(String name){
this.name = name;
}
public String getName(){
return this.name;
}
public String toString(){
return this.name;
}
}
class Student extends Person{
Student(String name){
super(name);
}
}
import java.util.*;
class Gen{
public static void main(String[] args){
ArrayList<Person> al1 = new ArrayList<Person>();
al1.add(new Person("zhangsan"));
al1.add(new Person("lisi"));
al1.add(new Person("wangwu"));
ArrayList<Student> al2 = new ArrayList<Student>();
al1.add(new Student("xuesheng1"));
al1.add(new Student("xuesheng2"));
al1.add(new Student("xuesheng3"));
printColl(al1);
printColl(al2);
}
public static void printColl(ArrayList<? extends Person> al){
Iterator<? extends Person> it = al.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
class Person{
private String name;
Person(String name){
this.name = name;
}
public String getName(){
return this.name;
}
public String toString(){
return this.name;
}
}
class Student extends Person{
Student(String name){
super(name);
}
}
3. ？ super E: 可以接收E类型或者E的父类型。下限
import java.util.*;
class Gen{
public static void main(String[] args){
//注意TreeSet的构造方法：Comparator里面比较的可以是E或者E的父类
//TreeSet(Comparator<? super E> comparator)
TreeSet<Student> ts = new TreeSet<Student>(new Comp());
ts.add(new Student("zhangsan"));
ts.add(new Student("a"));
ts.add(new Student("bcd"));
printColl(ts);
}
public static void printColl(TreeSet<? extends Person> ts){
Iterator<? extends Person> it = ts.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
class Person{
private String name;
Person(String name){
this.name = name;
}
public String getName(){
return this.name;
}
public String toString(){
return this.name;
}
}
class Student extends Person{
Student(String name){
super(name);
}
}
//注意TreeSet的构造方法：
//TreeSet(Comparator<? super E> comparator)
//Comparator里面比较的可以是E或者E的父类
//此例中比较器比较的是Student的父类
class Comp implements Comparator<Person>{
public int compare(Person p1,Person p2){
return p1.getName().compareTo(p2.getName());
}
}
第二讲 Collections
一、概述
Collections是对集合框架的一个工具类。它里边的方法都是静态的，不需要创建对象。并未封装特有数据。
在Collections工具类中大部分方法是用于对List集合进行操作的，如比较，二分查找，随机排序等。
二、常见操作
1、查找
T max(Collection<? extends T> coll);//根据集合的自然顺序，获取coll集合中的最大元素
T max(Collection<? extends T> coll,Comparator<? super T> comp);//根据指定比较器comp的顺序，获取coll集合中的最大元素
int binarySearch(Lsit<? extends Comparable<? super T>> list,Tkey);//二分法搜索list集合中的指定对象
2、替换
void fill(List<? super T> list, T obj);//将list集合中的全部元素替换成指定对象obj
boolean replaceAll(List<T> lsit,T oldVal,T newVal);//用newVal替换集合中的oldVal值
void swap(Listlist,int i,int j);/在指定列表的指定位置处交换元素
3排序：
void shuffle(List<?> list);//使用默认随机源对list集合中的元素进行随机排序
void sort(Lsit<T> list);//根据自然顺序对list集合中的元素进行排序
void sort(List<T> lsit,Comparator<? super T> c);//根据指定比较器c的排序方式对list集合进行排序
4、反转
reverse(List<?> list);//反转list集合中元素的顺序
Comparator reverseOrder();//返回一个比较器，强行逆转了实现Comparable接口的对象的自然顺序
Comparator reverseOrder(Comparator<T> cmp);//返回一个比较器，强行逆转了指定比较器的顺序
5、同步的集合
List<T> synchronizedList(List<T> list);//返回支持的同步（线程安全的）List集合
Map<K,V> synchronizedList(Map<K,V> m);//返回支持的同步（线程安全的）Map集合
三、Collections和Collection的区别
Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。
它有两个常用的子接口：
List：对元素都有定义索引。有序的。可以重复元素。
Set：不可以重复元素。无序
Collections是集合框架中的一个工具类。该类中的方法都是静态的。提供的方法中有可以对list集合进行排序，二分查找等方法
通常常用的集合都是线程不安全的。因为要提高效率。如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。
/*
需求：使用Collections中的方法fill对List集合中的部分元素进行替换
思路：1、将List集合中要替换的部分元素取出,并存入另一集合中
2、将原集合中的要替换元素移除
3、用fill将要替换的元素进行替换
4、将取出的部分增加进集合
*/
import java.util.*;
class FillTest
{
public static void main(String[] args)
{
List<String> list = new ArrayList<String>();
list.add("abc");
list.add("ab");
list.add("abcd");
list.add("a");
list.add("abcde");
try
{
fillSome(list,1,5,"shenma");
}
catch (InputException e)
{
System.out.println(e.toString());
}
System.out.println(list);
}
//替换部分元素方法
public static void fillSome(List<String> list,int start,int end,String s)throws InputException
{
if(start>=end)
throw new InputException("没有要替换的元素");//如果输入的end小于或者等于start，则抛出异常
//定义一个新集合
List<String> li=new ArrayList<String>();
//因为每移除一次，后面的元素就会补上，所以这里用y来控制次数
for (int x=start,y=start;y<end ; y++)
{
li.add(list.get(x));//将需要替换的元素增加到新集合
list.remove(x);//移除需要替换的元素
}
Collections.fill(li,s);//替换成需要的元素s
list.addAll(start,li);//将替换的部分增加进原集合
}
}
//自定义异常
class InputException extends Exception
{
InputException(String Massage)
{
super(Massage);
}
}
第三讲 Arrays
一、概述
Arrays是用于操作数组的工具类。里边的方法也全是静态的。不需要创建对象。
把数组变成List集合的好处：可以使用集合的思想和方法来操作数组中的元素。如：contains，get，indexOf，subList等方法。
二、常见方法
1、Lsit<T> asList(T... a);//将数组转换为集合
注意：
a、将数组转换成集合，不可使用集合的增删方法，因为数组的长度是固定的。如果进行增删操作，通过编译，但运行时会因产生UnsupportedOperationException异常而中断运行。
b、如果数组中的元素都是对象，则变成集合时，数组中的元素就直接转为集合中的元素。
c、如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
2、binarySearch()：二分查找方法，fill()：替换方法，sort()：排序方法等
特点：可对数组元素进行相应操作，可以接受除boolean之外的其他各种基本数据类型及有序的引用类型数组的参数，且还可以对指定元素的范围，并可根据指定比较器进行相应的操作。
如：sort(T[]a,Comparator<? super T> c)
fill(int[]a,int from,int to)等
3、String toString();//可以接收各种数组类型参数，并返回指定数组内容的字符串表现形式。
import java.util.*;
class Test
{
public static <T> void sop(T t){
System.out.println(t);
}
public static void main(String[] args)
{
int[] arr = {2,4,5};
String s = Arrays.toString(arr);
sop(s);
//把数组变成list集合有什么好处？
/*
可以使用集合的思想和方法来操作数组中的元素。
注意：将数组变成集合，不可以使用集合的增删方法。
因为数组的长度是固定。
contains。
get
indexOf()
subList();
如果你增删。那么会反生UnsupportedOperationException */
String[] ss = {"aaa","bbb","ccc"};
List ls = Arrays.asList(ss);
sop("contains:"+ls.contains("bbb"));
sop("indexof:"+ls.indexOf("bbb"));
// ls.add("UnsupportedOperationException");
/*
如果数组中的元素是对象。那么变成集合时，集合中的元素与数组元素类型相同。
如果数组中的元素是基本数据类型，变成集合时，该数组作为集合中的唯一元素存在。
*/
int[] numbers = {2, 5, 7};
List lnumbers = Arrays.asList(numbers);
sop(lnumbers);//[[I@19e0bfd] List内的元素类型为 int[] 类型
Integer[] num = {2, 5, 7};
List list = Arrays.asList(num);
sop(list);//[2, 5, 7] List内的元素类型为Integer
}
}
/*
集合变数组。
Collection接口中的toArray方法。
*/
import java.util.*;
class Test
{
public static <T> void sop(T t){
System.out.println(t);
}
public static void main(String[] args)
{
List<String> list = new ArrayList<String>();
list.add("hello");
list.add("a");
list.add("b");
list.add("c");
list.add("d");
/*
1,指定类型的数组到底要定义多长呢？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。
所以创建一个刚刚好的数组最优。
2,为什么要将集合变数组？
为了限定对元素的操作。不需要进行增删了。
*/
String[] ss = list.toArray(new String[5]);
sop(Arrays.toString(ss));
}
}
2. 增强for循环
高级for循环
格式：
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
{ }
对集合进行遍历。
只能获取集合元素。但是不能对集合进行操作。
迭代器除了遍历，还可以进行remove集合中元素的动作。
如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。
传统for和高级for有什么区别呢？
高级for有一个局限性。必须有被遍历的目标。
建议在遍历数组的时候，还是希望是用传统for。因为传统for可以定义脚标。
/*
例子：用增强for循环遍历HashMap
*/
import java.util.*;
class Test
{
public static <T> void sop(T t){
System.out.println(t);
}
public static void main(String[] args)
{
Map<String , Integer> map = new HashMap<String , Integer>();
map.put("abc", 11);
map.put("def", 12);
map.put("hjk", 13);
Set<String> set = map.keySet();
//Iterator<String> it = set.iterator();
for(String s : set){
sop("key: "+ s + " value: "+map.get(s));
}
for(Map.Entry<String, Integer> entry : map.entrySet()){
sop(entry.getKey()+" "+entry.getValue());
}
}
}
分享到：
发表评论
-
Reflect
2015-05-13 00:34 383第一讲 反射的应用 ... -
Regular Expression
2015-05-06 15:50 429正则表达式 一、概述 1、 概念：符合一定规则 ... -
网络编程
2015-05-04 12:07 437第一讲 概述 1、网络模型：OSI参考模型和TCP/ ... -
System、Runtime、Date、DateFormat、Calendar、Math、Random
2015-03-15 00:55 464第一讲 System类 一、概述 1、System是描 ... -
多线程
2015-03-14 22:23 372一、多线程概述 ... -
Java IO
2015-03-08 23:26 559第一讲 什么是IO? ...
相关推荐
C# 泛型（Generic） 泛型（Generic） 允许您延迟编写类或方法中的编程元素的数据类型的规范，直到实际在程序中使用它的时候。换句话说，泛型允许您编写一个可以与任何数据类型一起工作的类或方法。 您可以通过数据...
例如，我们可以创建一个名为`GenericContainer<T>`的泛型类，其中`T`就是类型参数。这个类可以存储任何类型的对象，但具体类型在实例化时确定。这样做的好处是，我们无需为每种可能的数据类型创建单独的类，从而提高...
Generic Programming（泛型程序设计小手册）中文chm版
泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是...
陈广的泛型(Generic)教程
泛型在编程中是一种强大的工具，特别是在C#和.NET框架中，它允许程序员创建可复用的类型安全的代码，可以处理多种数据类型。在上述示例中，我们看到两个不同的场景，一个是非泛型的堆栈实现，另一个是使用.NET框架中...
泛型编程是C++编程语言中的一个重要概念，它允许我们...通过阅读和实践“泛型演算法Generic Algorithms與Function Objects”中的内容，开发者能够提升在C++编程中的泛型编程技巧，从而更好地利用STL提供的强大工具。
泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是...
在《java-generic.rar》压缩包中包含的《java generic.pdf》文件，很可能是详细阐述了以下几个关于Java泛型的核心知识点： 1. **类型参数化**：泛型的核心在于类型参数化，这使得我们可以在定义类、接口和方法时...
在C++/CLI中声明泛型类或方法时，使用`generic <typename T>`关键字，其中`T`是类型参数。例如，可以创建一个泛型栈`Stack`，如下所示： ```cpp generic ref class Stack { public: void Push(ItemType item) {…}...
From Mathematics to Generic Programming 数学与泛型编程：高效编程的奥秘 英文版
早在JDK1.3时，随着GJ（Generic Java）的出现，Java社区开始探索泛型的可能性。GJ是一个支持泛型特性的Java编译器插件，为后续的泛型技术发展奠定了基础。到了JDK1.4，通过JSR#14的支持，泛型技术以插件的形式得到了...
在Spring 4.0中，一个重要的改进是引入了对泛型依赖注入的支持，这使得开发者可以更加精确地控制依赖关系，从而提高了代码的可读性和类型安全性。在描述的示例中，我们看到`BaseDao`是一个泛型抽象类，它有一个泛...
泛型擦除（Generic erase）（教学视频+源代码） 源代码中使用的泛型，在经过编辑后，代码中就看不到泛型，也就是所谓的泛型擦除 泛型擦除不是泛型丢失了，而是在编译后的字节码文件中使用单独的标识来存储泛型了。...
### Java 泛型数组的理解与应用 #### 一、引言 Java 泛型是 Java SE 5.0 引入的新特性，它允许在编译时检查类型安全，并且所有的强制转换都是自动和隐式的，提高了代码的重用率。然而，在 Java 中创建泛型数组却...
在这个示例中，`GenericClass`被声明为泛型类，其中`T`是类型参数。创建`GenericClass`的实例时，我们指定了`String`作为类型实参，因此`set`和`get`方法都只能接受或返回`String`类型的值。 ### 泛型通配符 泛型...
数学和泛型编程-高效编程的奥秘（英文版pdf）原名：From_Mathematics_to_Generic_Programming，作者;Alexander A. Stepanov Daniel E. Rose
当创建泛型类的实例时，需要在尖括号内指定具体的类型，如`GenericClass<Integer>`或`GenericClass<String>`。 ### 泛型继承 泛型继承是指一个类继承自另一个泛型类，子类可以选择指定或不指定父类的类型参数。...