javase
来源：互联网 发布：anaconda 改成python 2 编辑：程序博客网 时间：2024/04/27 17:10
01. 快捷键
ctrl + shift + f 快速格式化代码alt + / 联想ctrl + d 删除光标选中行alt + up/down 移动代码alt + ctrl + up/down 快速复制代码ctrl + / 单行注释/取消注释ctrl + shift + / 多行注释ctrl + shift + \ 取消多行注释shift + enter 另起一行ctrl + 鼠标左键 定位代码02. Scanner
public static void main(String[] args) { // 1.得到一个扫描器 Scanner sc = new Scanner(System.in); System.out.println("请输入一个整数: "); // 2.通过扫描器获取一个输入 int i = sc.nextInt(); System.out.println("输入的数是" + i); System.out.println("请输入一串字符串"); String s = sc.next(); SYstem.out.println(s);}03. 方法
应用的一些思路原则: 复用 可读性 模块化alt + shift + m 快速封装方法04. 一维数组的声明
int[] a; int a1[]; a = new int[] { 1, 2, 3, 4, 5 }; int[] a2 = new int[] { 11, 12, 13, 234 }; System.out.println(a); System.out.println(a[0]); // 1 a[0] = 2; System.out.println(a[0]); // 205. 冒泡排序
for(int i = 0; i < a.length-1; i++) { for(int j = 0; j < a.length-1-i); j++) { if(a[j] > a[j+1]) { int tmp = a[j]; a[j] = a[j+1]; a[j+1] = tmp; } }}06. 二维数组的声明
/* 二维数组是一维数组的数组*/ int [][] a; int a1[][]; // 不建议使用 a = new int[][] {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; System.out.println(a[0][1]); // 2/* 第二种声明方式*/ int[][] a3 = new int[2][3]; a[0][0] = 1; int[][] a4 = new int[2][]; System.out.println(a4[0]); // null a4[0] = new int[]{ 1, 2, 3 };/* 二维数组遍历*/ for(int i = 0; i < a.length; i++) { for(int j = 0; j < a[i].length; j++) { System.out.print(a[i][j] + " "); } System.out.println(); }07. 面向对象
public class Person { String name; // 变量名最好望文知意 int age; String sex; String phone; public void printName() { System.out.println(name); } public static void main(String[] args) { Person p = new Person(); }}08. 构造方法
new + 构造方法 创建对象 a. 构造方法不用声明返回值类型 b. 构造方法必须与类同名 c. 每一个类都必须至少拥有一个构造方法 如果没有声明构造方法的话,jvm会默认生成一个无参的构造方 法，一旦声名了构造方法将不再自动生成. d. 构造方法的调用构造方法只能通过 new + 构造方法 调用，一旦调用必将创建一个新对象，构造方法在对象创建成功之后09. 方法的重载
overload允许在一个类当中声明多个方法名称相同，但是参数不同的多个方法。参数不同: 参数个数不同 参数类型不同注意: 当在方法调用的时候如果调入方法传入参数时不能严格匹配到相同的类型参数方法的时候，按参数默认转换的顺序，就近去匹配一个方法10. 关键字
this 在对象内部用于指向对象本身static 作用: 修饰成员变量以及方法注意: 对于静态的成员变量，每个当前类型的对象都能访问得到，并且访问的是同一个数据。 建议对静态的成员变量使用的时候通过类名引用Person.age = 12;静态的成员变量在类加载的时候创建，之后不会再被创建修饰方法的时候可以直接被调用静态的方法中不能访问非静态的成员变量和方法类名.方法名(参数);11. 继承(inherit)
public class Student extends Person { /* 子类可以在继承的基础上新增自己的成员变量 父类发生改变子类也随之改变 一个子类只能继承一个父类 一个父类可以派生出多个子类 子类还可以拥有自己的子类 */}12. 访问权限修饰符
13. 方法的重写(override)
作用： 当子类对父类继承下来的方法不满意的时候声明一个方法把他覆盖掉前提： 继承、方法名相同、不能有更严格的权限14. super关键字
a. 在子类对象中指向父类部分子类重写父类的某个方法，如果想在子类对象中去调用被重写的方法的话要用super指明public void printInfo() { super.printInfo(); System.out.println();}15. 对象转型(ObjectCast)
向上转型: 父类引用指向子类对象Person p1 = new Student();向下转型: 子类引用指向父类对象Student s = (Student)p1;16.抽象类
不能被实例,化只能被继承public abstract class Game { public abstract void play();}抽象方法没有方法体抽象类不一定要有抽象方法子类继承父类，如果父类中有抽象方法必须重写一个类继承于抽象类如果不想重写抽象方法，那么这个类也必须是抽象类17. 接口interface
public interface Anime { /* 接口中所有的成员变量都是常量 接口中所有的方法都是抽象方法 可以将魔鬼数字声明在接口内 */ public static final int A = 1; public abstract void (); } public class Cat implements Anime { public void m(){ System.out.println("被重写的方法"); } }18. 内部类
public class TestWai { int a = 1; // 成员内部类 // 成员内部类可以使用四中权限修饰符修饰 class TestNei { public TestNei(){ } }}public class Test { public static void main(String[] args) { // 1.创建外部类对象 TestWai tw = new TestWai(); // 2.内部类对象创建，已导包 TestNei tn = tw.new TestNei(); // 2.未导包的创建方式 TestWai.TestNei tn = tw.new TestNei(); }}// 在外部类中引用内部类对象public void test() { TestNei tn = this.ew TestNei();}/* 静态成员内部类 静态成员内部类不依赖外部类对象*/public class TestWai { int i; static class TestNei { public void f() { // 静态的成员内部类是不能访问外部类中非静态的成员变量以及方法 } }}public class Test { public static void main(String[] args) { // 1.有导包可以直接创建引用 TestNei tn = new TestNei(); // 2.没导包 TestWai.Testnei tn = new TestWai.TestNei(); }}/* 局部内部类 声明在方法体或者语句块中 不能使用 static 修饰 可以访问外部类的成员变量 生效范围: 声明时所在的大括号内部*//* 匿名内部类 声明一个没有名称的内部类继承于另外一个类*/19. 枚举enum
public emum Color { BLUE,RED,YELLOW}public emum Color { BLUE("蓝色",1),RED("红色，2); private Strign name; private int code; private Color(String name,int code) { this.name = name; this.code = code; }}public class Test { Color c = Color.RED; switch(c) { case RED: System.out.println("红色"); }}20. String类
常用方法: char charAt(int index); int length(); int indexOf(String str); int indexOf(String str,int fromIndex); boolean equalsIgnoreCase(String another); String replace(char oldChar,char newChar); boolean startsWith(String prefix); boolean endsWith(String suffix); String toUpperCase(); String toLowerCase(); String substring(int beginIndex); String substring(int beginIndex,int endIndex); String trim(); == 比较的是引用 equals 比较的是内容 建议常量写在前面 "男".equals(s); valueOf(基本数据类型) 可以将基本数据类型转换成字符串 // 按照指定的分隔符分割，返回分割后的字符串 String[] split(String regex);21. 正则表达式
Pattern p = new Pattern.compile(正则表达式);Matcheer m = p.macher(要判断的字符串);boolean b = m.matches(); // 判断是否符合22. StringBuffer
常用方法 .append(字符串); .toString();23. 随机类Random
Random r = new Random(); int nextInt = r.nextInt(10); // 0~9随机 System.out.println(nextInt);24. 日期类Date
// 表示的是时间是对象创建的瞬间 Date date = new Date(); // 表示的时间是当前传入的时间 Date date2 = new Date(121341232L); // 获取对象的时间 long time = date.getTime(); System.out.println(date2); // 判断date2的时间是否在date之后 boolean after = date2.after(date); // 判断date2的事件是否在date之前 boolean before = date2.before(date); 25.SimpleDateFormat
/* SimpleDateFormat 简单的日期转换类 作用: 可以把时间用一定模式的字符串表示 把一定模式的字符串转成其表示的时间*/ SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss" String format = sdf.format(date); System.out.println(format);//文本转换成日期,文本描述要跟模式一致 String time = "2016年01月02日 12:10:21"; try{ Date parse = sdf.parse(time); System.out.println(parse.getTime()); } catch (ParseException e) { e.printStackTrace(); }26. 日历类Calendar
/* Calendar 作用:提供一系列时间字段获取的方法，以及可以定位某个事件字段以及以当前时间为基准进行微调的方法*/ // 获取日历对象 初始时间: 获取的这一瞬间时间 Calendar cal = Calendar.getInstance(); // 时间段信息的提取 Date time = cal.getTime(); long timeInMillis = cal.getTimeInMillis(); int year = cal.get(Calendar.YEAR); int month = cal.get(Calendar.Month); // 具体请查找官方文档27. System类
// 获取系统当前时间 long currentTime = System.currentTimeMillis(); // 复制数组 System.out.arraycopy(src,srcPos,dest,destPos,length);28. 异常
Throwable所有错误以及异常的父类 -Error 错误的父类 -Exception 异常的父类public class Anime throws IOException { public static void main(String[] args) { try { // 执行可能会发生异常代码,发生异常后,后面的代码不执行 } catch(Exception e) { //手动抛异常 throw 要抛的异常 // 发生异常时要执行的代码 } finally { // 无论怎样都会被执行的代码 } }}29. 容器
Collection -Set(无序、不可重复) --HashSet -List(有序、可重复) --LinkedList --ArrayListMap -HashMap Collection c = new HashSet(); // 添加成功返回true boolean b = c.add("abc"); // 获取容器保存元素的长度 int size = c.size; // 判断容器是否为空 boolean empty = c.isEmpty(); // 清除容器中所有的元素 c.clear(); // 查看是否包含某个元素 boolean contains = c.contains(new Person()); // 移除某个对象成功返回true boolean remove = c.remove(new Person);泛型
/* 可以严格规定容器中保存的数据类型 泛型类型一定是引用类型*/Collection<Person> c = new HashSet<Person>();// jdk1.7之后Collection<Person> c = new HashSet<>();Iterator接口
/* 所有实现了Collection接口的容器类都有一个iterator返回一个实现了Iterator接口的对象。 Iterator对象称作迭代器，用于方便实现对容器内元素的遍历操作 判断游标右边的是否有元素 boolean hashNext(); 返回游标右边的元素并将游标移动到下一个位置 Object next(); 删除游标左边的元素 void remove()*/ //得到得到迭代器对象 Iterator<String> iterator = c.iterator(); while(iterator.hasNext()) { String s = iterator.next(); if("234".equals(s)) { iterator.remove(); } }/* 注意:在迭代过程中是不允许使用容器本身的方法删除数据 要删除数据只能使用迭代器本身提供的remove()方法*/ // for each 只能做简单的遍历 for(String s : c) { System.out.println(s); }List
/* List重置了两个remove()方法 一个是新增的参数为int 一个是从Collection继承下来的参数为Object*/ // 通过索引删除 Iteger remove = list.remove(1); // 比较两个元素是否相等直接删除 list.remove(new Integer(1)); // List遍历 for(int i = 0; i < list.size(); i++) { Integer integer = list.get(i); System.out.println(integer); }Map
以键值对形势保存，key不能重复 HashMap<String,String> hm = new HashMap<>(); // 在添加的时候容器中如果没有对应的key存在的话，返回null // 如果已经存在会替换原来的value,并返回原来的value String put1 = hm.put("A","abc"); String put2 = hm.put("B","dsa"); // 通过指定key返回value String s = hm.get("B"); //删除指定key的元素 String remove = hashMap.remove("N"); // 查看是否包含指定key booelan containKey = hm.containsKey("B"); // 查看是否包含指定value boolean containsValue = hm.containsValue("dsad"); // 遍历 // 1.把HashMap中所有key映射成为一个set容器 Set<String> keySet = hm.keySet(); // 2.得到Set容器的迭代器 Iterator<String> iterator = keySet.iterator(); while(iterator.hashNext()) { String key = iterator.next(); String value = hm.get(key); } // 更高效的遍历 Set<Entry<String,String>> entry = hm.entrySet(); Iterator<Entry<String,String>> iterator = entry.iterator(); while(iterator.hashNext()) { String key = iterator.next(); String value = hm.get(key); }Collections类
提供一些列用于操作容器的静态方法// 对容器内的元素排序,前提是保存的元素是可以排序的，可以通过实现Comparable接口void sort(List);// 对容器内的对象随机排序void shuffle(List);// 对容器内的对象进行逆序排序void reverse(List);// 用特定的对象初始化整个容器void fill(List,Object);// 采用折半查找法查找特定的元素int binarySearch(List,Object);调用方法 Collections.方法名(容器);Arrays类
提供一系列操作数组的静态方法// 对数组进行排序Arrays.sort(i);// 使用指定的元素初始化数组Arrays.fill(i,2);// 将数组转变成字符串Arrays.toString(i);// 二分法查询Arrays.binarySearch(i,要查找的元素);// 比较两个数组内容是否一致Arrays.equals(i,a);// 获取二维数组的字符串形式Arrays.deepToString(s);Comparable接口
实现此接口的类，重写compareTo()方法，可以让这个类具备比较大小的能力Comparator接口
实现此接口的类具备比较两个对象大小的能力重写compare(Object o1,Object o2)方法使用Collections.sort(arrayList,new Caipan());泛型类
/* T 就是泛型，只是一种指代，只有在对象创建的时候才能确定是什么类型*/public class Person<T,M> { T o; M m; public T getO(){ return o; } public void setO(T o) { this.o = o; }}public static void main(String[] args) { Person<String,String> p = new Person<>(); // 如果不使用泛型就不受泛型的限制 Person p2 = new Person(); p2.setO("asd");}泛型的继承
// 更加严格规定泛型的类型// 在确定泛型的时候，该泛型只能是Animal类型或者其子类public class Person<T extends Animal> { T o; public T getO() { return o; }}public static void main(String[] args) { Person<Animal> p1 = new Person<>(); //如果不使用泛型的话，类型默认是继承的类型 Person p2 = new Person(); // 会报错}通配符(占位符) ?
一般在方法形参中声明 // f需要的参数有泛型规定，具体类型不确定所以用?表示 // 但是这个?所表示类型一定是Cat或者Cat类型的子类 public static void f(Person<? extend Cat> p) { } // 这里的?所表示的类型一定是Cat或者Cat类型的父类 public static void k(Person<? super Cat> p) { }泛型方法
//泛型规定的范围只在方法中 public static<T> set(T o) { return o; } // 使用 Integer set = set(1); String set2 = set("asd");30. IO流
文件流
/* 设置保存的文件路径 路径只能是文件不能是文件夹 如果文件不存在，输出流会自动创建 如果字符串所表示路径的父文件夹不存在也会出现问题*/// 写文件 String path = "d:\\a.txt"; String src = "abcdefg"; // 把字符串转换成当前平台的字节编码 byte[] bytes = src.getBytes(); FileOutputStream fos = null; try { // 创建一个输出流对象 // 一个新的输出流对象往文件中写数据的话会把原数据覆盖 fos = new FileOutputStream(path); // 在构造方法中传入true表示往原文件拼接 // fos = new FileOutputStream(path,true); //写入字节数组中的所有内容 fos.write(bytes); // fos.write(40); // 字节数组中下标0开始，取3位写入 // fos.write(bytes, 0, 3); // 刷新缓存，确保不会残留数据 fos.flush(); } catch(Exception e) { } finally { if (fos != null) { try { // 不使用的时候要把流关闭 fos.close(); } catch (IOException e) { } } }//读文件 // 设置读取文件的路径 String path = "D:\\a.txt"; FileInputStream fis = null; try { // 创建一个输入流对象 fis = new FileInputStream(path); // byte[] b = newe byte[100]; // int read = fis.read(b); // int read2 = fis.read(b, 0, 10); // int read3 = fis.read(); // 创建一个StringBuffer用于保存每次读取到的字符串 StringBuffer sb = new StringBuffer(); int len = 0; // 保存每一次读取的内容在字节数组中 byte[] b = new byte[1024]; // 从文件中读取字符并将其保存在字节数组中 // 读取不到返回-1 while(-1 != (len = fis.read(b))){ // 将字节数组转换成字符串 String s = new String(b,0,len); sb.append(s); } String src = sb.toString(); System.out.println("读取到的字符串为"+src); } catch(Exception e) { } finally { if (fis != null) { try { // 关闭输入流 fis.close(); } catch (IOException e) { } } }字符流
//FileWriter public static void main(String[] args) { // 要写入的位置 String path = "d:\\a.txt"; // 要写入的数据 String src = "abcdefghijkl"; // 得到字符数组 char[] charArray = src.toCharArray(); FileWriter fw = null; try { fw = new FileWriter(path); // 写字符数组 fw.write(charArray); // 从字符数组第0位置取3个写入 //fw.write(charArray, 0, 3); //fw.write(src); // 从字符串第0位置开始取3个写入 //fw.write(src, 0, 3); fw.flush(); } catch (IOException e) { e.printStackTrace(); } finally { if (fw != null) { fw.close(); } } }//FileReader public static void main(String[] args) { String path = "d:\\a.txt"; FileReader fr = null; try { fr = new FileReader(path); StringBuffer sb = new StringBuffer(); int len = 0; char[] cbuf = new char[1024]; while(-1 != (len = fr.read(cbuf)) { String s = new Stirng(cbuf, 0, len); sb.append(s); } System.out.println(sb); } catch (FileNotFoundException e) { e.printStackTrace(); } finally { if (fr != null) { fr.close(); } } }对象流
// 要读写的对象必须实现序列号接口,然后生成版本ID public class Person implement serializable { // 生成序列号版本ID private static final long serialVersionUID = 1L; }// ObjectOutputStream public static void main(String[] args) { // 要保存的路径 String path = "d:\\a.txt"; Person p = new Person("A",12); // 只要关闭最外层流 ObjectOutputStream oos = null; try { FileOutputStream fos = new FileOutputStream(path); oos = new ObjectOutputStream(fos); oos.writeObject(p); oos.writeInt(12); oos.flush(); } catch (FileNotFoundException e) { } finally { if (oos !=null) { oos.close(); } } }// ObjectInputStream public static void main(String[] args) { String path = "d:\\a.txt"; ObjectInputStream ois = null; try { FileInputStream fis = new FileInputStream(path); ois = new ObjectInputStream(fis); Person readObject = ois.readObject(); int readInt = ois.readInt(); } catch (FileNotFoundException e) { } finally { if (ois != null) { ois.close(); } } }/* 要实现对象流读写的话，累必须实现序列号接口 序列号版本ID的作用 如果没有显示声明序列化版本ID的话，系统会自动生成，但类的数据发生改变的话，序列号版本ID也会跟着改变,读取的时候如果序列号版本不一致就不能实现数据解析*/缓存流
属于处理流作用: 采用了缓存技术对节点流或其他处理流进行优化 字节流跟字符流都有对应的缓存流 字节缓存流 BufferedInputStream/BufferedOutputStream 注意: 缓存输出流在数据写完之后要flash() 字符缓存流 BufferedWriter/BufferedReader 注意: 新增了按行读写的方法 readLine()/new Line()数据流
DataInputStream/DataOutputStream作用: 可以直接读写基本数据类型的数据注意: 数据流是属于字节流的处理流 数据流读写的时候一定要注意顺序要一致打印流
只有输出没有输入属于处理流字节流: printStream System.out System.err字符流: printWriter public static void main(String[] args) { String path = "D:\\a.txt"; FileOutputStream fos = new FileOutputStream(path); PrintStream ps = new PrintStream(fos); // 设置系统的打印流 System.setOut(ps); // 把系统地打印流设置回控制台 FileOutputStream fos1 = new FileOutputStream(FileDescriptor.out); PrintStream ps1 = new PrintStream(fos1); // 设置系统的打印流 System.setOut(ps1); }转换流
OutputStreamWriter/InputStreamReader处理流属于字符流作用: 把字节流转换成字符流场景: 得到别的方法返回的字节流，但是我们要读取纯文本，字符流对于纯文本读取效果比较好,所以可以把字节转换成字符注意: 可以处理乱码问题31.多线程
进程: 一个正在执行的应用程序就是一个进程 每个进程都有自己独立的内存空间线程: 程序中一条代码执行的路径 每一个进程中至少要包含一条正在执行的线程 每条线程都有自己独立的内存空间, 在一定程度上线程之间可以共享内存空间多进程: 一个操作系统中同时执行多个应用程序多线程: 一个程序内部同时又多条路径正在执行 作用: 提高程序的执行效率Thread
基于封装的思想, 一个Thread类型的对象封装了一条线程的属性信息, 包括线程的状态, 并且提供一系列对于这条线程操作的方法注意: 1.有start()才有新线程开启 2.start()这个方法是执行在被调用的线程中 3.开启的新线程的入口就是当前这个Thread对象中的run()方法,run()方法中再调用的方法就属于子线程的路径public class MyThread extends Thread { // 在对象创建的时候传入参数为线程命名 public MyThread(String name) { super(name); } @override public void run() { // 这条语句运行在哪条线程就可以获取这条线程对应的Thread对象 Thread thread = Thread.currentThread(); // 获取线程的名称 String n = thread.getName(); System.out.println(n); }}class Test { public static void main(String[] args) { Thread thread = Thread.currentThread(); String name = thread.getName(); // main MyThread myThread = new MyThread("子线程"); myThread.start(); // "子线程" myThread.run(); // main }}// 声明方式2// 创建一个类实现Runnable接口public class MyRunnable implements Runnable { @override public void run() { String name = Thread.currentThread.getName(); System.out.println(name); }}public class Test { public static void main(String[] args) { Runnable target = new MyRunnable(); // 创建一个Thread对象把Runnable对象的引用传入 new Thread(target,"子线程").start(); }}Thread类提供的方法: 1.isAlive() 判断线程是否存在 2.getPriority() 获得线程的优先级数值 3.setPriority() 设置线程的优先级数值 4.Thread.sleep() 将当前线程睡眠,没有放开锁 5.join() 6.yield() 让出CPU,当前线程进入就绪状态 7.wait() 当前线程进入对象的wait pool 8.notify() 唤醒一个wait pool中的线程 9.notify() 唤醒所有wait pool中的线程线程锁
线程同步: 当多条线程同时去操作同一个数据，如果是默认的抢先式的话,有可能会出现临界问题语法: synchronized(钥匙) { // 钥匙为任意非空的对象 //被锁住的代码 // 执行完后才会放开钥匙的所有权 // 等待钥匙的时候当前线程是处于阻塞状态 }锁方法: public synchronized void add() { } 等同于 public void add() { synchronized(this) { } }/* 当成钥匙的也可以是类 synchronized(Test.class) { // 不建议使用 } 线程锁中可以继续加锁 避免产生死锁 条件: 1.锁中有锁 2.不同线程加锁使用钥匙正好交叉了wait()/notify()/notifyAll() 只能在被锁住的代码中使用*/线程池
作用: 管理线程 限制同一时间执行的线程数量, 复用线程, 提高效率 // 同一时间只能执行一条线程的线程池 ExecutorService executor = Executors.newSingleThreadExecutor(); // 同一时间执行指定数目的线程池 ExecutorService executor = Executors.newFixedThreadPool(2); // 可以缓存的线程池(60秒内没有使用自动销毁) ExecutorService executor = Executors.newCachedThreadPool(); MyTask t1 = new MyTask("任务1"); MyTask t2 = new MyTask("任务2"); MyTask t3 = new MyTask("任务3"); MyTask t4 = new MyTask("任务4"); executor.execute(t1); // 提交要执行在子线程的任务 executor.execute(t2); executor.execute(t3); executor.execute(t4); executor.shutdown(); // 关闭线程池32.定时器
java.util.Timer TimerTask注意: 如果定时器任务要重复执行的话, 那么一次 任务最好不要有耗时操作class MyTask extends TimerTask { private Timer timer; int index; public MyTask(Timer timer) { this.timer = timer; } @Override public void run() { index++; System.out.println(index); if(index >= 5) { timer.cancel(); } }} public static void main(String[] args) { Timer timer = new Timer(); TimerTask task = new MyTask(timer); timer.schedule(task,1000); // 提交后1000毫秒后执行 timer.schedule(task,new Date(321312L)); // 指定时间开始执行任务 }33.单例模式
public class Test { // 私有化构造方法 private Test(){} // 饿汉模式 private static Test ton = new Test(); public static Test getInstance() { return ton; } // 懒汉模式 private static Test ton; public static synchronized Test getInstance() { if (ton == null) { ton = new Test(); } return ton; } }/* 步骤: 1.私有化构造方法 2.生命一个静态的当前类型的成员变量，用于保存实例化对象的引用 3.生命一个公共的静态的方法，用于返回实例化对象的引用*/34.网络编程
客户端
public class TestClient{ @SuppressWarnings("resource") public static void main(String[] args) { try { //1.创建一个Socket对象去连接服务端 //在对象创建的时候要确定服务端的IP以及端口号 //本机IP 127.0.0.1 localhost Socket socket = new Socket("127.0.0.1", 8888); //通过Socket获取一个输入流(字节输入流)// InputStream is = socket.getInputStream();// DataInputStream dis = new DataInputStream(is);// OutputStream os = socket.getOutputStream();// DataOutputStream dos = new DataOutputStream(os);// // String readUTF = dis.readUTF();//阻塞式方法// System.out.println(readUTF);// dos.writeUTF("你好!服务端！"); new ReadThread(socket).start(); new WriteThread(socket).start(); } catch (UnknownHostException e){ } catch (IOException e) { } }}class ReadThread extends Thread { private Socket socket; private DataInputStream dis; private boolean isLoop = true; public ReadThread(Socket socket) { this.socket = socket; try { InputStream is = socket.getInputStream(); dis = new DataInputStream(is); } catch (IOException e) { } } public boolean isLoop() { return isLoop; } public void setLoop(boolean isLoop) { this.isLoop = isLoop; } @Override public void run() { try { while (isLoop) { String readUTF = dis.readUTF(); System.out.println(readUTF); } } catch (IOException e) { } finally { if (socket != null) { try { socket.close(); } catch (IOException e) { } } } }}class WriteThread extends Thread { private Socket socket; private DataOutputStream dos; private boolean isLoop = true; Scanner scanner = new Scanner(System.in); public WriteThread(Socket socket) { this.socket = socket; try { OutputStream os = socket.getOutputStream(); dos = new DataOutputStream(os); } catch (IOException e) { e.printStackTrace(); } } public boolean isLoop() { return isLoop; } public void setLoop(boolean isLoop) { this.isLoop = isLoop; } @Override public void run() { try { while (isLoop) { String next = scanner.next(); dos.writeUTF("客户端:" + next); } } catch (IOException e) { } finally { if (socket != null) { try { socket.close(); } catch (IOException e) { } } } }}//----------------------------------------服务端
public class TestServer { @SuppressWarnings("resource") public static void main(String[] args) { try { // 1.创建一个ServerSocket对象，确定服务端的端口号 ServerSocket serverSocket = new ServerSocket(8888); // 2.调用accept()等待客户端连接，客户端连接成功之后产生一个Socket对象 // 这个Socket对象对应着连接到服务的Socket对象 // 两端之间的信息交互，就是由对应的这两个Socket对象处理的。 // 如果服务端要连接多个客户端就多次去调用accept()即可，调用一次等待一个客户端连接 Socket socket = serverSocket.accept(); // 通过Socket对象获取一个输出流(字节输出流)// OutputStream os = socket.getOutputStream();// // 数据输出流// DataOutputStream dos = new DataOutputStream(os);// // 通过Socket对象获取一个输入流(字节输入流)// InputStream is = socket.getInputStream();// DataInputStream dis = new DataInputStream(is);//// dos.writeUTF("你好！客户端");// String readUTF = dis.readUTF();// System.out.println(readUTF); new ReadThread(socket).start(); new WriteThread(socket).start(); } catch (IOException e) { } }}class ReadThread extends Thread { private Socket socket; private DataInputStream dis; private boolean isLoop = true; public ReadThread(Socket socket) { this.socket = socket; try { InputStream is = socket.getInputStream(); dis = new DataInputStream(is); } catch (IOException e) { e.printStackTrace(); } } public boolean isLoop() { return isLoop; } public void setLoop(boolean isLoop) { this.isLoop = isLoop; } @Override public void run() { try { while (isLoop) { String readUTF = dis.readUTF(); System.out.println(readUTF); } } catch (IOException e) { e.printStackTrace(); } finally { if (socket != null) { try { socket.close(); } catch (IOException e) { e.printStackTrace(); } } } }}class WriteThread extends Thread { private Socket socket; private DataOutputStream dos; private boolean isLoop = true; Scanner scanner = new Scanner(System.in); public WriteThread(Socket socket) { this.socket = socket; try { OutputStream os = socket.getOutputStream(); dos = new DataOutputStream(os); } catch (IOException e) { e.printStackTrace(); } } public boolean isLoop() { return isLoop; } public void setLoop(boolean isLoop) { this.isLoop = isLoop; } @Override public void run() { try { while (isLoop) { String next = scanner.next(); dos.writeUTF("服务端:" + next); } } catch (IOException e) { } finally { if (socket != null) { try { socket.close(); } catch (IOException e) { } } } }}Http
public class Test { @SuppressWarnings("resource") public static void main(String[] args) { String path = "http://localhost:8080/win32.zip"; String toPath = "d://win32.zip"; FileOutputStream fos = null; InputStream is = null; try { //1.得到URL对象 （统一资源定位器） URL url = new URL(path); //2.打开网络连接（请求） URLConnection connection = url.openConnection(); connection.setConnectTimeout(3000);//设置连接超时时间 connection.setReadTimeout(3000);//设置读取超时时间 is = connection.getInputStream();//获取输入流 fos = new FileOutputStream(toPath); int len = 0; byte[] b = new byte[1024]; while(-1 != (len = is.read(b ))) { fos.write(b, 0, len); } fos.flush(); } catch (MalformedURLException e) { } catch (IOException e) { } finally { if(is != null) { try { is.close(); } catch (IOException e) { } } if(fos != null) { try { fos.close(); } catch (IOException e) { } } } }} 0 0
- javaSE
- javaSE
- javaSE
- JavaSE
- javase
- javase
- javaSE
- JAVASE
- JavaSE
- Javase
- javase
- javase
- JavaSE
- JAVASE
- JavaSE
- JAVASE
- JavaSE
- javase
- 递归的定义以及递归的示例(计算阶乘、计算斐波那契数、递归二分查找、回文串递归方法解决、汉诺塔问题、递归选择排序问题)
- kafka笔记
- BZOJ1272: [BeiJingWc2008]Gate Of Babylon
- objective-c 中new与alloc/init的区别
- dir函数：遍历文件名
- javase
- 插入排序、希尔排序、冒泡排序、快速排序、选择排序、堆排序、归并排序
- css3媒体查询
- gcc configure: error: Building GCC requires GMP 4.2+, MPFR 2.3.1+ and MPC 0.8.0+
- 使用bootstrap-pagination进行分页
- 2016-8-9夏令营总结(网络流—增广路+dinic)
- POJ3211--分类01背包
- 32位单片机 一个32位地址代表一个字节而不是4个字节（32位）
- HTML5-CSS布局
