首页 文章 精选 留言 我的

精选列表

搜索[techo day],共2891篇文章
优秀的个人博客,低调大师

预警| WebLogic Server曝高风险远程命令执行0-day漏洞,阿里云WAF支持免费应急服务

近日,阿里云安全团队监测到,由国家信息安全漏洞共享平台(CNVD)收录的Oracle WebLogic wls9-async反序列化远程命令执行漏洞(CNVD-C-2019-48814)被攻击者利用,在未授权的情况下可远程执行命令。该漏洞曾经因为使用HTTP协议,而非t3协议,被黑客利用进行大规模的挖矿行为。 目前该漏洞对WebLogic 10.X和WebLogic 12.1.3两个版本均有影响。Oracle尚未发布官方补丁,漏洞细节和真实PoC也未公开。 一、WebLogic Server漏洞是啥? WebLogic Server是美国甲骨文(Oracle)公司开发的一款适用于云环境和传统环境的应用服务中间件,它提供了一个现代轻型开发平台,支持应用从开发到生产的整个生命周期管理,被广泛应用于保险、证券、银行等金融领域。 二、WebLog

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day5)——我所知道的标识符和关键字

好多计算机语言都有标识符和关键字,一直没有好好的总结,就是这样的用着,现在小小的整理一下Swift中的标识符和关键字。 什么是标识符呢? 标识符就是给变量、常量、方法、函数、枚举、结构体、类、协议等由开发人员指定的名字。 其实,构成标识符的字母是有一定规范的,Swift中命名规则是: 区分大小写,Myname与myname是两个不同的标识符; 标识符首字符可以以下划线(_)或者字母开始,但不能是数字; 标识符中其他字符可以是下划线(_)、字母或数字。 例如:userName、User_Name、_sys_val、身高等为合法的标识符,而2mail、room#和class为非法的标识符。 什么是关键字呢? 关键字是类似于标识符的保留字符序列,由语言本身定义好的,不能挪作他用,除非用重音符号(`)将其括起来。A Swift语言常见的关键字有以下4种。 与声明有关的关键字:class、deinit、enum等。 与语句有关的关键字:break、case、continue等。 表达式和类型关键字:as、catch、dynamicType、false等。 在特定上下文中使用的关键字:associativity、convenience、dynamic等。 Swift中关键字是区分大小写的,所以class和Class是不同的,那么Class不是Swift的关键字。 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1744589,如需转载请自行联系原作者

优秀的个人博客,低调大师

Day2 鸿蒙的Text,相较于Android的TextView看看控件通用属性有什么不一样

在鸿蒙的DevEco-Studio中新建工程模板的控件Text属性如下: ohos:id="$+id:text_helloworld" ohos:height="match_content" ohos:width="match_content" ohos:background_element="$graphic:background_ability_main" ohos:layout_alignment="horizontal_center" ohos:text="Hello World" ohos:text_size="50" 1、id(通用属性) id,控件的唯一标识。 【Android】 @+id:android:id="@+id/名称" 表示创建该控件的id @id:android:id="@id/名称" 表示引用其他控件的id 【鸿蒙】 @+id:ohos:id="$+id:名称" 表示创建该控件的id @id:未出现该用法 2、height、width(通用属性) height,布局文件的一个属性。 【Android】 @layout_height:android:layout_height="属性/数值" 表示该控件的高度 @layout_width:android:layout_width="属性/数值" 表示该控件的高度 *属性列表: wrap_content:是layout_width和layout_height的属性值之一,表示和自身内容一样的长度。 match_parent:是layout_width和layout_height的属性值之一,表示和父组件一样的长度。 (1)和wrap_content配合: 先按照内容的多少去设定空间大小,然后按照权重的比例分配剩余控件。即当控件没有内容或内容未超出按照权重比例分配的空间时,就按照layout_weight设定的权重比例分配空间,当内容大小超过这样分配的空间时,控件就会扩张,其实就是按照wrap_content来占用空间了,剩下的空间仍然按照本段定理来分配。 (2)和match_parent配合: 空间计算公式:空间大小=父容器大小+权重比例剩余空间大小,比如两个同级控件A,B都是match_parent,A的layout_weight为1,B的layout_weight为2(总空间为1match_parent,所需空间为2match_parent,剩余空间为两者之差),空间A=1match_parent+1/(1+2)(1match_parent-2match_parent)=2/3match_parent,同理,空间B=1/3match_parent。这个现象和正常情况有些相反,但是可以有效保证空间分配到的比例固定,不会被内容撑大。 (3)和0dp配合: 将layout_weight或者layout_height设为0dp,将直接按照layout_weight权重的比例分配空间,且不会被内容撑大。 *数值列表 px、dp、dip、sp、mm、in、pt (1)px: 即像素,1px代表屏幕上一个物理的像素点; px单位不被建议使用,因为同样100px的图片,在不同手机上显示的实际大小可能不同。 偶尔用到px的情况,是需要画1像素表格线或阴影线的时候,用其他单位如dp会显得模糊。 (2)dp: 这个是最常用但也最难理解的尺寸单位。它与“像素密度”密切相关,所以首先我们解释一下什么是像素密度。假设有一部手机,屏幕的物理尺寸为1.5英寸x2英寸,屏幕分辨率为240x320,则我们可以计算出在这部手机的屏幕上,每英寸包含的像素点的数量为240/1.5=160dpi(横向)或320/2=160dpi(纵向),160dpi就是这部手机的像素密度,像素密度的单位dpi是Dots Per Inch的缩写,即每英寸像素数量。横向和纵向的这个值都是相同的,原因是大部分手机屏幕使用正方形的像素点。 不同的手机/平板可能具有不同的像素密度,例如同为4寸手机,有480x320分辨率的也有800x480分辨率的,前者的像素密度就比较低。Android系统定义了四种像素密度:低(120dpi)、中(160dpi)、高(240dpi)和超高(320dpi),它们对应的dp到px的系数分别为0.75、1、1.5和2,这个系数乘以dp长度就是像素数。例如界面上有一个长度为“80dp”的图片,那么它在240dpi的手机上实际显示为80x1.5=120px,在320dpi的手机上实际显示为80x2=160px。如果你拿这两部手机放在一起对比,会发现这个图片的物理尺寸“差不多”,这就是使用dp作为单位的效果,见下图。 是不是所有android手机的屏幕宽度用dp衡量都是固定值(例如320dp)呢?答案是否定的,如果写一个程序画宽度等于320dp的横线,在不同手机上运行,会发现在有些手机上横线比手机屏幕短,有些则比屏幕长,在平板上与手机上相比差别则更加明显。 (3)dip: 与dp完全相同,只是名字不同而已。在早期的Android版本里多使用dip,后来为了与sp统一就建议使用dp这个名字了。 (4)sp: 与缩放无关的抽象像素(Scale-independent Pixel)。sp和dp很类似但唯一的区别是,Android系统允许用户自定义文字尺寸大小(小、正常、大、超大等等),当文字尺寸是“正常”时1sp=1dp=0.00625英寸,而当文字尺寸是“大”或“超大”时,1sp>1dp=0.00625英寸。类似我们在windows里调整字体尺寸以后的效果——窗口大小不变,只有文字大小改变。 (5)mm:(比较少用到) 即毫米; (6)in:(比较少用到) 即英寸,1英寸=2.54厘米(约); (7)pt:(比较少用到) 1pt=1/72英寸=0.035厘米; 最佳实践,文字的尺寸一律用sp单位,非文字的尺寸一律使用dp单位。例如textSize="16sp"、layout_width="60dp";偶尔需要使用px单位,例如需要在屏幕上画一条细的分隔线时: layout_width="match_parent" layout_height="1px" 【鸿蒙】 @height:ohos:height="属性/数值" 表示该控件的高度 @width:ohos:width="属性/数值" 表示该控件的高度 *属性列表: match_content:是width和height的属性值之一,表示和自身内容一样的长度。 match_parent:是width和height的属性值之一,表示和父组件一样的长度。 *数值列表(目前还没有找到文档介绍,待后续更新): fp、px、vp 本文由博客一文多发平台 OpenWrite 发布!

优秀的个人博客,低调大师

java基础学习_集合类02_List的子类、泛型、增强for循环、静态导入、可变参数_day16总结

==========================================================================================================================================================涉及到的知识点有:1:List的子类(掌握) (1)List的子类特点 (2)ArrayList类 (3)Vector类 (4)LinkedList类 (5)案例2:泛型(掌握) (1)泛型的概述 (2)泛型的格式 (3)泛型的好处 (4)泛型的前世今生 (5)我们在哪里使用呢?3:增强for循环(掌握)4:静态导入(了解) (1)静态导入的概述 (2)静态导入的格式 (3)注意事项5:可变参数(掌握) (1)可变参数的概述 (2)可变参数的格式 (3)注意事项 (4)Arrays工具类中的一个方法6:练习(掌握) A:集合的嵌套遍历 B:产生10个1-20之间的随机数,要求随机数不能重复 C:键盘录入多个数据,以0结束,并在控制台输出最大值7:要掌握的代码==========================================================================================================================================================1:List的子类(掌握) (1)List的子类特点 ArrayList: 底层数据结构是数组,查询快,增删慢 线程不安全,效率高 Vector: 底层数据结构是数组,查询快,增删慢 线程安全,效率低 LinkedList: 底层数据结构是链表,查询慢,增删快 线程不安全,效率高 (2)ArrayList类 A:没有特有功能需要学习 B:案例 a:ArrayList存储字符串并遍历 b:ArrayList存储自定义对象并遍历 (3)Vector类 A:有特有功能 a:添加功能 public void addElement(E obj) -- add() b:获取功能 public E elementAt(int index) -- get() public Enumeration<E> elements() -- Iterator iterator() 抽象方法: boolean hasMoreElements() -- hasNext() Object nextElement() -- next() JDK升级的原因: A:提高安全 B:提高效率 C:简化书写 B:案例 a:Vector存储字符串并遍历 b:Vector存储自定义对象并遍历 (4)LinkedList类 A:有特有功能 a:添加功能 public void addFirst(Object e) 在最前面添加 public void addLast(Object e) 在最后面添加(该功能意义不大) b:删除功能 public Object removeFirst() public Object removeLast() c:获取功能 public Object getFirst() public Obejct getLast() B:案例 a:LinkedList存储字符串并遍历 b:LinkedList存储自定义对象并遍历 (5)案例 A:去除集合中的多个字符串的重复元素 如果字符串的内容相同,即为重复元素。 法一: 1 package cn.itcast_04; 2 3 import java.util.ArrayList; 4 import java.util.Iterator; 5 6 /* 7 * ArrayList去除集合中字符串的重复值(字符串的内容相同) 8 * 9 * 分析: 10 * A:创建集合对象 11 * B:添加多个字符串元素(包含内容相同的) 12 * C:创建新集合 13 * D:遍历旧集合,获取得到每一个元素 14 * E:拿这个元素到新集合去找,看有没有 15 * 有:不搭理它 16 * 没有:就添加到新集合 17 * F:遍历新集合 18 */ 19 public class ArrayListDemo { 20 public static void main(String[] args) { 21 // 创建集合对象 22 ArrayList array = new ArrayList(); 23 24 // 添加多个字符串元素(包含内容相同的) 25 array.add("hello"); 26 array.add("world"); 27 array.add("java"); 28 array.add("world"); 29 array.add("java"); 30 array.add("world"); 31 array.add("world"); 32 array.add("world"); 33 array.add("world"); 34 array.add("java"); 35 array.add("world"); 36 37 // 创建新集合 38 ArrayList newArray = new ArrayList(); 39 40 // 遍历旧集合,获取得到每一个元素 41 Iterator it = array.iterator(); 42 while (it.hasNext()) { 43 String s = (String) it.next(); 44 45 // 拿这个元素到新集合去找,看有没有 46 if (!newArray.contains(s)) { 47 newArray.add(s); 48 } 49 } 50 51 // 遍历新集合 52 for (int x = 0; x < newArray.size(); x++) { 53 String s = (String) newArray.get(x); 54 System.out.println(s); 55 } 56 } 57 58 } ArrayListDemo.java 法二(不常用): 1 package cn.itcast_04; 2 3 import java.util.ArrayList; 4 import java.util.Iterator; 5 6 /* 7 * 需求:ArrayList去除集合中字符串的重复值(字符串的内容相同) 8 * 要求:不能创建新的集合,就在以前的集合上做。 9 */ 10 public class ArrayListDemo2 { 11 public static void main(String[] args) { 12 // 创建集合对象 13 ArrayList array = new ArrayList(); 14 15 // 添加多个字符串元素(包含内容相同的) 16 array.add("hello"); 17 array.add("world"); 18 array.add("java"); 19 array.add("world"); 20 array.add("java"); 21 array.add("world"); 22 array.add("world"); 23 array.add("world"); 24 array.add("world"); 25 array.add("java"); 26 array.add("world"); 27 28 // 由选择排序思想引入,我们就可以通过这种思想做这个题目 29 // 拿0索引的依次和后面的比较,有就把后的干掉 30 // 同理,拿1索引... 31 // 因为ArrayList底层数据结构是数组,而数组查询快,增删慢 32 for (int x = 0; x < array.size() - 1; x++) { 33 for (int y = x + 1; y < array.size(); y++) { 34 if (array.get(x).equals(array.get(y))) { 35 array.remove(y); // 因为你删一个的同时,剩下的数组会挤上去一个,而挤上的这一个没有判断 36 y--; // 所以我要再回去比较一下 37 } 38 } 39 } 40 41 // 遍历集合 42 Iterator it = array.iterator(); 43 while (it.hasNext()) { 44 String s = (String) it.next(); 45 System.out.println(s); 46 } 47 } 48 } ArrayListDemo2.java B:去除集合中的多个自定义对象的重复元素 如果自定义对象的成员变量值都相同,即为重复元素。 1 package cn.itcast_04; 2 3 import java.util.ArrayList; 4 import java.util.Iterator; 5 6 /* 7 * 需求:去除集合中自定义对象的重复值(对象的成员变量值都相同) 8 * 9 * 我们按照和字符串一样的操作,发现出问题了。 10 * 为什么呢? 11 * 我们必须思考哪里会出问题? 12 * 通过简单的分析,我们知道问题出现在了判断上。 13 * 而这个判断功能是集合自己提供的,所以我们如果想很清楚的知道它是如何判断的,就应该去看源码。 14 * contains()方法的底层依赖的是equals()方法。 15 * 而我们的学生类中没有equals()方法,这个时候,默认使用的是它父亲Object的equals()方法。 16 * Object()的equals()默认比较的是地址值,所以,它们进去了。因为new的东西,地址值都不同。 17 * 按照我们自己的需求,比较成员变量的值,重写equals()即可。 18 * 自动生成即可。 19 */ 20 public class ArrayListDemo3 { 21 public static void main(String[] args) { 22 // 创建集合对象 23 ArrayList array = new ArrayList(); 24 25 // 创建学生对象 26 Student s1 = new Student("林青霞", 27); 27 Student s2 = new Student("林志玲", 40); 28 Student s3 = new Student("凤姐", 35); 29 Student s4 = new Student("芙蓉姐姐", 18); 30 Student s5 = new Student("翠花", 16); 31 Student s6 = new Student("林青霞", 27); 32 Student s7 = new Student("林青霞", 18); 33 34 // 添加元素到集合 35 array.add(s1); 36 array.add(s2); 37 array.add(s3); 38 array.add(s4); 39 array.add(s5); 40 array.add(s6); 41 array.add(s7); 42 43 // 创建新集合 44 ArrayList newArray = new ArrayList(); 45 46 // 遍历旧集合,获取得到每一个元素 47 Iterator it = array.iterator(); 48 while (it.hasNext()) { 49 Student s = (Student) it.next(); 50 51 // 拿这个元素到新集合去找,看有没有 52 if (!newArray.contains(s)) { 53 newArray.add(s); 54 } 55 } 56 57 // 遍历新集合 58 for (int x = 0; x < newArray.size(); x++) { 59 Student s = (Student) newArray.get(x); 60 System.out.println(s.getName() + "---" + s.getAge()); 61 } 62 } 63 } ArrayListDemo3.java 1 package cn.itcast_04; 2 3 public class Student { 4 private String name; 5 private int age; 6 7 public Student() { 8 super(); 9 } 10 11 public Student(String name, int age) { 12 super(); 13 this.name = name; 14 this.age = age; 15 } 16 17 public String getName() { 18 return name; 19 } 20 21 public void setName(String name) { 22 this.name = name; 23 } 24 25 public int getAge() { 26 return age; 27 } 28 29 public void setAge(int age) { 30 this.age = age; 31 } 32 33 @Override 34 public boolean equals(Object obj) { 35 if (this == obj) 36 return true; 37 if (obj == null) 38 return false; 39 if (getClass() != obj.getClass()) 40 return false; 41 Student other = (Student) obj; 42 if (age != other.age) 43 return false; 44 if (name == null) { 45 if (other.name != null) 46 return false; 47 } else if (!name.equals(other.name)) 48 return false; 49 return true; 50 } 51 52 } Student.java C:用LinkedList模拟一个栈数据结构的集合类,并测试。 你要定义一个集合类,只不过内部可以使用LinkedList来实现(模拟)。 这样做的好处是:我们用自己的方法,让外界不知道我们用的是谁. package cn.itcast_05; import java.util.LinkedList; /** * 自定义的栈集合 * * @author 风清扬 * @version V1.0 */ public class MyStack { private LinkedList link; public MyStack() { link = new LinkedList(); } public void add(Object obj) { link.addFirst(obj); } public Object get() { // return link.getFirst(); return link.removeFirst(); // 移除第一个元素并返回被移除的元素,其余的元素自动向上挤 } public boolean isEmpty() { return link.isEmpty(); } } package cn.itcast_05; /* * MyStack的测试 */ public class MyStackDemo { public static void main(String[] args) { // 创建集合对象 MyStack ms = new MyStack(); // 添加元素,底层调用的是addFirst(obj); ms.add("hello"); // 第一个进来,压栈,最里面 ms.add("world"); // 第二个进来,压栈 ms.add("java"); // 第三个进来,压栈 // 改进前 // 改进后 // System.out.println(ms.get()); // java java // System.out.println(ms.get()); // java world // System.out.println(ms.get()); // java hello // NoSuchElementException // System.out.println(ms.get()); 异常 while (!ms.isEmpty()) { System.out.println(ms.get()); } } } -----------------------------------------------------------------------------2:泛型(掌握) (1)泛型的概述 是一种 把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的 特殊的类型。也叫参数化类型,把类型当作参数一样进行传递。 (2)泛型的格式 <数据类型> 注意:该数据类型只能是引用类型。 (3)泛型的好处 A:把运行时期的问题提前到了编译期间 B:避免了强制类型转换 C:优化了程序设计,解决了黄色警告线问题,让程序更安全 (4)泛型的前世今生 A:泛型的由来 早期的Object类型可以接收任意的对象类型,但是在实际的使用中,向上转型是没有任何问题的,但是在向下转型的时候其实隐含了类型转换的问题。 也就存在这隐患,所以Java在JDK1.5以后就提供了泛型来解决这个安全问题,提高程序的安全性。 B:泛型类 把泛型定义在类上 格式:public class 类名<泛型类型1, 泛型类型2, ...> 注意:泛型类型必须是引用数据类型。因为仅仅表示一个参数,所以符合我们命名的标识符规则就行。 public class ObjectTool<T> {...} C:泛型方法 把泛型定义在方法上 格式:public <泛型类型> 返回类型 方法名(泛型类型 泛型名) 注意:方法能接收任意类型的参数 public <T> void show(T t) {...} D:泛型接口 把泛型定义在接口上 格式:public interface 接口名<泛型类型1, 泛型类型2, ...> 注意:把泛型定义在接口上,该接口的实现类是实现的那一刻就知道类型的(不常见),还是以后用的时候才知道类型的(常见)。 public class InterImpl<T> implements Inter<T> {...} E:泛型高级通配符 ? 任意类型,如果没有明确,那么就是Object以及任意的Java类了(泛型如果明确地写的时候,前后必须一致) ? extends E 向下限定,E及其子类 ? super E 向上限定,E及其父类 1 package cn.itcast_07; 2 3 import java.util.ArrayList; 4 import java.util.Collection; 5 6 /* 7 * 泛型高级(通配符) 8 * ? 任意类型,如果没有明确,那么就是Object以及任意的Java类了 9 * ? extends E 向下限定,E及其子类 10 * ? super E 向上限定,E及其父类 11 */ 12 public class GenericDemo { 13 public static void main(String[] args) { 14 // 泛型如果明确地写的时候,前后必须一致 15 Collection<Object> c1 = new ArrayList<Object>(); 16 // Collection<Object> c2 = new ArrayList<Animal>(); // 编译报错 17 // Collection<Object> c3 = new ArrayList<Dog>(); // 编译报错 18 // Collection<Object> c4 = new ArrayList<Cat>(); // 编译报错 19 20 // ? 任意类型,如果没有明确,那么就是Object以及任意的Java类了 21 Collection<?> c5 = new ArrayList<Object>(); 22 Collection<?> c6 = new ArrayList<Animal>(); 23 Collection<?> c7 = new ArrayList<Dog>(); 24 Collection<?> c8 = new ArrayList<Cat>(); 25 26 // ? extends E 向下限定,E及其子类 27 // Collection<? extends Animal> c9 = new ArrayList<Object>(); // 编译报错 28 Collection<? extends Animal> c10 = new ArrayList<Animal>(); 29 Collection<? extends Animal> c11 = new ArrayList<Dog>(); 30 Collection<? extends Animal> c12 = new ArrayList<Cat>(); 31 32 // ? super E 向上限定,E及其父类 33 Collection<? super Animal> c13 = new ArrayList<Object>(); 34 Collection<? super Animal> c14 = new ArrayList<Animal>(); 35 // Collection<? super Animal> c15 = new ArrayList<Dog>(); // 编译报错 36 // Collection<? super Animal> c16 = new ArrayList<Cat>(); // 编译报错 37 } 38 } 39 40 class Animal { 41 } 42 43 class Dog extends Animal { 44 } 45 46 class Cat extends Animal { 47 } GenericDemo.java (5)我们在哪里使用呢? 看API,如果类、接口、抽象类的后面跟有<E>就说要使用泛型。一般来说就是在集合中使用。 // JDK7的新特性:泛型推断。 // ArrayList<Student> array = new ArrayList<>(); // 但是我不建议这样使用。 ArrayList<Student> array = new ArrayList<Student>();----------------------------------------------------------------------------- 3:增强for循环(掌握) (1)是for循环的一种。增强for是用来替迭代器。 (2)格式 for (元素的数据类型 变量名 : 数组或者Collection集合的对象) { 使用该变量即可,该变量其实就是数组或者集合中的元素。 } (3)好处 简化了数组和集合的遍历。 (4)弊端 增强for循环的目标不能为null。建议在使用前,先判断是否为null。 即:对增强for的目标先进行不为null的判断,然后再使用。 1 package cn.itcast_01; 2 3 import java.util.ArrayList; 4 import java.util.List; 5 6 /* 7 * JDK5的新特性:自动拆装箱、泛型、增强for、静态导入、可变参数、枚举 8 * 9 * 增强for:是for循环的一种。 10 * 11 * 格式: 12 * for (元素数据类型 变量 : 数组或者Collection集合) { 13 * 使用变量即可,该变量就是元素 14 * } 15 * 16 * 好处:简化了数组和集合的遍历。 17 * 18 * 弊端: 增强for的目标不能为null。 19 * 如何解决呢?对增强for的目标先进行不为null的判断,然后再使用。 20 */ 21 public class ForDemo { 22 public static void main(String[] args) { 23 // 定义一个int数组 24 int[] arr = { 1, 2, 3, 4, 5 }; 25 for (int x = 0; x < arr.length; x++) { 26 System.out.println(arr[x]); 27 } 28 System.out.println("---------------"); 29 // 增强for 30 for (int x : arr) { 31 System.out.println(x); 32 } 33 System.out.println("---------------"); 34 // 定义一个字符串数组 35 String[] strArray = { "林青霞", "风清扬", "东方不败", "刘意" }; 36 // 增强for 37 for (String s : strArray) { 38 System.out.println(s); 39 } 40 System.out.println("---------------"); 41 // 定义一个集合 42 ArrayList<String> array = new ArrayList<String>(); 43 array.add("hello"); 44 array.add("world"); 45 array.add("java"); 46 // 增强for 47 for (String s : array) { 48 System.out.println(s); 49 } 50 System.out.println("---------------"); 51 52 List<String> list = null; 53 // NullPointerException 54 // 这个s是我们从list里面获取出来的,在获取前,它肯定还要做一个判断 55 // 说白了,这就是迭代器的功能 56 if (list != null) { 57 for (String s : list) { 58 System.out.println(s); 59 } 60 } 61 62 // 增强for其实是用来替代迭代器的 63 // ConcurrentModificationException 64 // for (String s : array) { 65 // if ("world".equals(s)) { 66 // array.add("javaee"); 67 // } 68 // } 69 // System.out.println("array:" + array); 70 } 71 } ForDemo.java -----------------------------------------------------------------------------4:静态导入(了解) (1)静态导入的概述 可以直接导入到方法的级别 (2)静态导入的格式 import static 包名....类名.方法名; (3)注意事项 A:被导入的方法必须是静态的 B:如果有多个类下有同名的静态方法,就不好区分了,必须加上前缀才能导入。 所以一般我们并不使用静态导入,但是一定要能够看懂。 1 package cn.itcast_03; 2 3 /* 4 * 可变参数:定义方法的时候不知道该定义多少个参数 5 * 格式: 6 * 修饰符 返回值类型 方法名(数据类型… 变量名){ 7 * 8 * } 9 * 10 * 注意: 11 * 这里的变量其实是一个数组 12 * 如果一个方法有可变参数,并且有多个参数,那么,可变参数的位置肯定是在最后 13 */ 14 public class ArgsDemo { 15 public static void main(String[] args) { 16 // 2个数据求和 17 int a = 10; 18 int b = 20; 19 int result = sum(a, b); 20 System.out.println("result:" + result); // 30 21 22 // 3个数据的求和 23 int c = 30; 24 result = sum(a, b, c); 25 System.out.println("result:" + result); // 60 26 27 // 4个数据的求和 28 int d = 30; 29 result = sum(a, b, c, d); 30 System.out.println("result:" + result); // 90 31 32 // 需求:我要写一个求和的功能,到底是几个数据求和呢,我不太清楚,但是我知道在调用的时候我肯定就知道了。 33 // 为了解决这个问题,Java就提供了一个东西:可变参数 34 result = sum(a, b, c, d, 40); 35 System.out.println("result:" + result); // 130 36 37 result = sum(a, b, c, d, 40, 50); 38 System.out.println("result:" + result); // 180 39 } 40 41 public static int sum(int... a) { 42 // System.out.println(a); // [I@1f297e7 43 // return 0; 44 45 int s = 0; 46 47 for (int x : a) { 48 s += x; 49 } 50 51 return s; 52 } 53 54 // public static int sum(int a, int b, int c, int d) { 55 // return a + b + c + d; 56 // } 57 // 58 // public static int sum(int a, int b, int c) { 59 // return a + b + c; 60 // } 61 // 62 // public static int sum(int a, int b) { 63 // return a + b; 64 // } 65 } ArgsDemo.java -----------------------------------------------------------------------------5:可变参数(掌握) (1)可变参数的概述 如果我们在写方法的时候,参数个数不明确,就应该定义可变参数。 (2)可变参数的格式 修饰符 返回值类型 方法名(数据类型… 变量名){ } public static int sum(int... a) { } (3)注意事项 虽然可以把数组转成集合,但是集合的长度不能改变。 (4)Arrays工具类中的一个方法 public static <T> List<T> asList(T... a) 把数组转成集合 注意:虽然可以把数组转成集合,但是集合的长度不能改变。 因为这个集合的本质是数组。 1 package cn.itcast_03; 2 3 import java.util.Arrays; 4 import java.util.List; 5 6 /* 7 * Arrays工具类中的一个方法 8 * public static <T> List<T> asList(T... a) 把数组转成集合 9 * 10 * 注意事项: 11 * 虽然可以把数组转成集合,但是集合的长度不能改变。 12 */ 13 public class ArraysDemo { 14 public static void main(String[] args) { 15 // 定义一个数组 16 // String[] strArray = { "hello", "world", "java" }; 17 // List<String> list = Arrays.asList(strArray); 18 19 List<String> list = Arrays.asList("hello", "world", "java"); 20 // UnsupportedOperationException 不支持的操作异常 21 // list.add("javaee"); 22 // UnsupportedOperationException 不支持的操作异常 23 // list.remove(1); 24 list.set(1, "javaee"); // 可以修改 25 26 for (String s : list) { 27 System.out.println(s); 28 } 29 } 30 } ArraysDemo.java -----------------------------------------------------------------------------6:练习(掌握) A:集合的嵌套遍历 1 package cn.itcast_01; 2 3 public class Student { 4 private String name; 5 private int age; 6 7 public Student() { 8 super(); 9 } 10 11 public Student(String name, int age) { 12 super(); 13 this.name = name; 14 this.age = age; 15 } 16 17 public String getName() { 18 return name; 19 } 20 21 public void setName(String name) { 22 this.name = name; 23 } 24 25 public int getAge() { 26 return age; 27 } 28 29 public void setAge(int age) { 30 this.age = age; 31 } 32 33 } Student.java 1 package cn.itcast_01; 2 3 import java.util.ArrayList; 4 5 /* 6 * 集合的嵌套遍历 7 * 需求: 8 * 我们班有学生,每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList<Student> 9 * 但是呢,我们旁边是不是还有班级,每个班级是不是也是一个ArrayList<Student>。 10 * 而我现在有多个ArrayList<Student>。也要用集合存储,怎么办呢? 11 * 就是这个样子的:ArrayList<ArrayList<Student>> 12 */ 13 public class ArrayListDemo { 14 public static void main(String[] args) { 15 // 创建大集合 16 ArrayList<ArrayList<Student>> bigArrayList = new ArrayList<ArrayList<Student>>(); 17 18 // 创建第一个班级的学生集合 19 ArrayList<Student> firstArrayList = new ArrayList<Student>(); 20 // 创建学生 21 Student s1 = new Student("唐僧", 30); 22 Student s2 = new Student("孙悟空", 29); 23 Student s3 = new Student("猪八戒", 28); 24 Student s4 = new Student("沙僧", 27); 25 Student s5 = new Student("白龙马", 26); 26 // 学生进班 27 firstArrayList.add(s1); 28 firstArrayList.add(s2); 29 firstArrayList.add(s3); 30 firstArrayList.add(s4); 31 firstArrayList.add(s5); 32 // 把第一个班级存储到学生系统中 33 bigArrayList.add(firstArrayList); 34 35 // 创建第二个班级的学生集合 36 ArrayList<Student> secondArrayList = new ArrayList<Student>(); 37 // 创建学生 38 Student s11 = new Student("诸葛亮", 30); 39 Student s22 = new Student("司马懿", 28); 40 Student s33 = new Student("周瑜", 26); 41 // 学生进班 42 secondArrayList.add(s11); 43 secondArrayList.add(s22); 44 secondArrayList.add(s33); 45 // 把第二个班级存储到学生系统中 46 bigArrayList.add(secondArrayList); 47 48 // 创建第三个班级的学生集合 49 ArrayList<Student> thirdArrayList = new ArrayList<Student>(); 50 // 创建学生 51 Student s111 = new Student("宋江", 40); 52 Student s222 = new Student("吴用", 35); 53 Student s333 = new Student("高俅", 30); 54 Student s444 = new Student("李师师", 22); 55 // 学生进班 56 thirdArrayList.add(s111); 57 thirdArrayList.add(s222); 58 thirdArrayList.add(s333); 59 thirdArrayList.add(s444); 60 // 把第三个班级存储到学生系统中 61 bigArrayList.add(thirdArrayList); 62 63 // 遍历集合 64 for (ArrayList<Student> array : bigArrayList) { 65 for (Student s : array) { 66 System.out.println(s.getName() + "---" + s.getAge()); 67 } 68 } 69 } 70 } ArrayListDemo.java B:产生10个1-20之间的随机数,要求随机数不能重复 1 package cn.itcast_02; 2 3 import java.util.ArrayList; 4 import java.util.Random; 5 6 /* 7 * 获取10个1-20之间的随机数,要求不能重复 8 * 9 * 用数组实现,但是数组的长度是固定的。 10 * 长度不好确定,所以我们使用集合实现。 11 * 12 * 分析: 13 * A:创建产生随机数的对象。 14 * B:创建一个存储随机数的集合。 15 * C:定义一个统计变量。从0开始。 16 * D:判断统计遍历是否小于10 17 * 是:产生一个随机数,判断该随机数在集合中是否存在。 18 * 如果不存在:就添加,统计变量++。 19 * 如果存在:就不搭理它。 20 * 否:不搭理它 21 * E:遍历集合 22 */ 23 public class RandomDemo { 24 public static void main(String[] args) { 25 // 创建产生随机数的对象。 26 Random r = new Random(); 27 28 // 创建一个存储随机数的集合。 29 ArrayList<Integer> array = new ArrayList<Integer>(); 30 31 // 定义一个统计变量。从0开始。 32 int count = 0; 33 34 // 判断统计遍历是否小于10 35 while (count < 10) { 36 // 产生一个随机数 37 int number = r.nextInt(20) + 1; 38 39 // 判断该随机数在集合中是否存在。 40 if (!array.contains(number)) { 41 // 如果不存在:就添加,统计变量++。 42 array.add(number); 43 count++; 44 } 45 } 46 47 // 遍历集合 48 for (Integer i : array) { 49 System.out.println(i); 50 } 51 } 52 } RandomDemo.java C:键盘录入多个数据,以0结束,并在控制台输出最大值 1 package cn.itcast_03; 2 3 import java.util.ArrayList; 4 import java.util.Arrays; 5 import java.util.Scanner; 6 7 /* 8 * 键盘录入多个数据,以0结束,要求在控制台输出这多个数据中的最大值。 9 * 10 * 分析: 11 * A:创建键盘录入数据对象 12 * B:键盘录入多个数据,我们不知道多少个,所以用集合存储 13 * C:以0结束,这个简单,只要键盘录入的数据是0,我就不继续录入数据了 14 * D:把集合转成数组 15 * E:对数组排序 16 * F:获取该数组中的最大索引的值 17 */ 18 public class ArrayListDemo { 19 public static void main(String[] args) { 20 // 创建键盘录入数据对象 21 Scanner sc = new Scanner(System.in); 22 23 // 键盘录入多个数据,我们不知道多少个,所以用集合存储 24 ArrayList<Integer> array = new ArrayList<Integer>(); 25 26 // 以0结束,这个简单,只要键盘录入的数据是0,我就不继续录入数据了 27 while (true) { 28 System.out.println("请输入数据:"); 29 int number = sc.nextInt(); 30 if (number != 0) { 31 array.add(number); 32 } else { 33 break; 34 } 35 } 36 37 // 把集合转成数组 38 // public <T> T[] toArray(T[] a) 39 Integer[] i = new Integer[array.size()]; 40 // Integer[] ii = array.toArray(i); 41 array.toArray(i); 42 // System.out.println(i); // [Ljava.lang.Integer;@6cd8737 43 // System.out.println(ii); // [Ljava.lang.Integer;@6cd8737 44 45 // 对数组排序 46 // public static void sort(Object[] a) 47 Arrays.sort(i); 48 49 // 获取该数组中的最大索引的值 50 System.out.println("数组是:" + arrayToString(i) + "最大值是:" + i[i.length - 1]); 51 } 52 53 // 把数组转换成字符串 54 public static String arrayToString(Integer[] i) { 55 StringBuilder sb = new StringBuilder(); 56 57 sb.append("["); 58 for (int x = 0; x < i.length; x++) { 59 if (x == i.length - 1) { 60 sb.append(i[x]); 61 } else { 62 sb.append(i[x]).append(", "); 63 } 64 } 65 sb.append("]"); 66 67 return sb.toString(); 68 } 69 } ArrayListDemo.java ----------------------------------------------------------------------------- 7:要掌握的代码 集合存储元素,加入泛型,并可以使用增强for遍历。=============================================================================我的GitHub地址: https://github.com/heizemingjun 我的博客园地址: http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址: http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军 【转载文章务必保留出处和署名,谢谢!】

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 68)——Cocoa Touch设计模式及应用之响应者链与触摸事件

应用与用户进行交互,依赖于各种各样的事件。事件响应者对象是可以响应事件并对其进行处理的对象,响应者链是由一系列链接在一起的响应者组成的。响应者链在事件处理中是非常重要的,响应者链可以把用户事件路由给正确的对象。 响应者对象与响应链 UIResponder是所有响应者对象的基类,它不仅为事件处理,而且也为常见的响应者行为定义编程接口。UIApplication、UIView(及其子类,包括UIWindow)和UIViewController(及其子类)都直接或间接地继承自UIResponder类。 第一响应者是应用程序中当前负责接收触摸事件的响应者对象(通常是一个UIView对象)。UIWindow对象以消息的形式将事件发送给第一响应者,使其有机会首先处理事件。如果第一响应者没有进行处理,系统就将事件(通过消息)传递给响应者链中的下一个响应者,看看它是否可以进行处理。 响应者链是一系列链接在一起的响应者对象,它允许响应者对象将处理事件的责任传递给其他更高级别的对象。随着应用程序寻找能够处理事件的对象,事件就在响应者链中向上传递。响应者链由一系列“下一个响应者”组成。 1.第一响应者将事件传递给它的视图控制器(如果有的话),然后是它的父视图。 2.类似地,视图层次中的每个后续视图都首先传递给它的视图控制器(如果有的话),然后是它的父视图。 3.最上层的容器视图将事件传递给UIWindow对象。 4.UIWindow对象将事件传递给UIApplication单例对象。 触摸事件 触摸(UITouch)对象表示屏幕上的一个触摸事件,访问触摸是通过UIEvent对象传递给事件响应者对象的。触摸对象有时间和空间两方面。 1.时间方面 时间方面信息称为阶段(phase),表示触摸是否刚刚开始、是否正在移动或处于静止状态,以及何时结束,也就是手指何时从屏幕抬起。 在给定的触摸阶段中,如果发生新的触摸动作或已有的触摸动作发生变化,则应用程序就会发送这些消息。 当一个或多个手指触碰屏幕时,发送touchesBegan:withEvent:消息。 当一个或多个手指在屏幕上移动时,发送touchesMoved:withEvent:消息。 当一个或多个手指离开屏幕时,发送touchesEnded:withEvent:消息。 2.空间方面 触摸点对象还包括当前在视图或窗口中的位置信息,以及之前的位置信息(如果有的话)。下面的方法是可以获得触摸点所在窗口或视图中的位置。 func locationInView(_ view:UIView?) -> CGPoint 获得前一个触摸点所在窗口或视图中的位置信息: func previousLocationInView(_view: UIView?) -> CGPoint 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1749103,如需转载请自行联系原作者

优秀的个人博客,低调大师

《从零开始学Swift》学习笔记(Day 71)——Swift与C/C++混合编程之数据类型映射

如果引入必要的头文件,在Objective-C语言中可以使用C数据类型。而在Swift语言中是不能直接使用C数据类型,苹果公司为Swift语言提供与C语言相对应数据类型。这些类型主要包括:C语言基本数据类型和指针类型。 C语言基本数据类型 如表所述是Swift数据类型与C语言基本数据类型对应关系表。 Swift语言中的这些数据类型与Swift原生的数据类型一样都,本质上都是结构体类型。我们可以他们的构造函数创建这些数据类型的实例。示例代码如下: 1 2 3 4 5 6 7 8 9 10 varintSwift= 80 //int varintNumber=NSNumber( int :CInt(intSwift)) //unsignedchar varunsignedCharNumber=NSNumber(unsignedChar:CUnsignedChar(intSwift)) //unsignedint varunsignedIntNumber=NSNumber(unsignedInt:CUnsignedInt(intSwift)) 变量intSwift所存储80是Int类型。代码中CInt(intSwift)是实例化CInt类型,它实现了将Int类型转化为C语言int类型,在Swift中使用CInt表示。 代码中CUnsignedChar(intSwift)是将Int类型转化为C语言unsigned char类型,在Swift中使用CUnsignedChar表示。 代码中的CUnsignedInt(intSwift))是将Int类型转化为C语言unsigned int类型,在Swift中使用CUnsignedInt表示。 C语言指针类型 如表所述是Swift数据类型与C语言指针数据类型对应关系表。 从表可见针对C语言多样的指针形式,Swift主要通过提供了三种不安全的泛型指针类型:UnsafePointer<T>、UnsafeMutablePointer<T>和AutoreleasingUnsafeMutablePointer<T>。T是泛型占位符,表示不同的数据类型。另外,还有COpaquePointer类型是Swift中无法表示的C指针类型。 下面我们分别介绍一下。 1.UnsafePointer<T> UnsafePointer<T>是一个比较常用的常量指针类型,这种指针对象需要程序员自己手动管理内存,即需要自己申请和释放内存。它一般是由其他的指针创建。它的主要的构造函数有: init(_ other: COpaquePointer)。通过COpaquePointer类型指针创建。 init<U>(_ from: UnsafeMutablePointer<U>)。通过UnsafeMutablePointer类型指针创建。 init<U>(_ from: UnsafePointer<U>)。通过UnsafePointer类型指针创建。 UnsafePointer<T>主要的属性: memory。只读属性,它能够访问指针指向的内容。 UnsafePointer<T>主要的方法: successor() -> UnsafePointer<T>。获得指针指向的下一个内存地址的内容。 predecessor() -> UnsafePointer<T>。获得指针指向的上一个内存地址的内容。 2. UnsafeMutablePointer<T> UnsafeMutablePointer<T>是一个比较常用的可变指针类型,这种指针对象需要程序员自己手动管理内存,自己负责申请和释放内存。可变指针可以由其他的指针创建,也可以可变指针通过alloc(_:)方法申请内存空间,再调用initialize(_:)方法初始化指针指向数值。当指针对象释放时候需要调用destroy()方法销毁指针指向对象,它是initialize(_:)方法的反向操作,他们两个方法在代码中应该成对出现的。最后还要调用dealloc(_:)方法释放指针指向的内存空间,它是alloc(_:)方法的反向操作,这两个方法在代码中也应该成对出现。 3. AutoreleasingUnsafeMutablePointer<T> AutoreleasingUnsafeMutablePointer<T>被称为自动释放指针,在方法或函数中声明为该类型的参数,是输入输出类型的,在调用方法或函数过程中,参数先首先被拷贝到一个无所有权的缓冲区,在方法或函数内使用的这个缓冲区,当方法或函数返回时,缓冲区数据重新写回到参数。 本文转自 tony关东升 51CTO博客,原文链接:http://blog.51cto.com/tonyguan/1749110,如需转载请自行联系原作者

优秀的个人博客,低调大师

绿盟科技互联网安全威胁周报2016.28 思科操作系统0Day漏洞CVE-2016-6415

绿盟科技发布了本周安全通告,周报编号NSFOCUS-16-28,绿盟科技漏洞库本周新增66条,其中高危14条。本次周报建议大家关注持续关注Cisco IOS操作系统信息泄露漏洞CVE-2016-6415,思科公司官方网站已针对该漏洞发布漏洞检测工具,但修复补丁暂未发布。 焦点漏洞 Cisco IOS操作系统信息泄露漏洞(CVE-2016-6415) NSFOCUS ID:33447 CVE ID:CVE-2016-6415 受影响版本 Cisco IOS XR 4.3.x Cisco IOS XR 5.0.x Cisco IOS XR 5.1.x Cisco IOS XR 5.2.x 漏洞点评 Cisco IOS网际操作系统是由思科公司开发的一个为网际互连优化的操作系统,广泛应用于该公司生产的各类防火墙和路由器等网络设备中。 该漏洞是由于上述系统对某网络

优秀的个人博客,低调大师

不是规则库 WAF:我们 Go 版把 Web 应用层 0day 免疫做成了 C2 + DNA 体系

摘要:很多人以为 WAF 就是“规则匹配 + IP 封禁 + 日志看板”,看完本文你会发现,我们 Go 版真正的核心不是规则库,而是一套 Web 应用层指挥控制体系:14 层编码归一化、YSL 语枢加权裁决、一手审计取证、攻击者画像、封禁网段、情报回灌,以及 DNA 零容忍秒级处置。本文把过去一直没系统对外讲清楚的 C2 能力和 DNA 能力完整梳理一遍。

优秀的个人博客,低调大师

java基础学习_集合类03_用户登录注册案例(集合版)、Set集合、Collection集合总结_day17总结

==========================================================================================================================================================涉及到的知识点有: 1:用户登录注册案例(集合版)(理解) 2:Set集合(理解) (1)Set集合的特点 (2)HashSet集合(掌握) (3)TreeSet集合(理解) (4)案例3:Collection集合总结(掌握) 4:针对Collection集合我们到底使用谁呢?(掌握) 5:在集合中常见的数据结构(掌握)==========================================================================================================================================================1:用户登录注册案例(集合版)(理解)-----------------------------------------------------------------------------2:Set集合(理解) (1)Set集合的特点 无序:存和取的顺序不一致,无索引,不可以存储重复元素(唯一)--------------------------------------- (2)HashSet集合(掌握) A:底层的数据结构是哈希表(是一个元素为链表的数组) B:哈希表底层依赖两个方法:hashCode()和equals() 执行顺序: 首先比较哈希值是否相同 相同:继续执行equals()方法 返回true:元素重复了,不添加 返回false:直接把元素添加到集合 不相同:就直接把元素添加到集合 C:如何保证元素唯一性的呢? 由hashCode()和equals()保证的。 即:int hashCode() boolean equals(Object obj) D:开发的时候,代码非常的简单,自动生成即可。 E:案例 1.HashSet存储字符串并遍历(注意:字符串默认重写了hasCode()和equals()方法) 2.HashSet存储自定义对象并遍历(对象的成员变量值都相同即为同一个元素) F:LinkedHashSet:底层的数据结构由哈希表和链表组成。 哈希表保证元素的唯一性。 链表保证元素有序。(存储和取出顺序一致) 注意事项: 1.一般来说,不同的字符串的哈希值是不同的。 哈希值仅仅是逻辑值,可能一样。 地址值是实际的物理值,不一样。 2.HashSet:它不保证 set 的迭代顺序;特别是它不保证该顺序恒久不变。 注意:虽然Set集合的元素无序,但是,作为集合来说,它肯定有它自己的存储顺序, 而你的顺序恰好和它的存储顺序一致,这代表不了有序,你可以多存储一些数据,就能看到效果。 --------------------------------------- (3)TreeSet集合(理解) A:底层数据结构是红黑树(是一个自平衡的二叉树)(自平衡:说明其结构不会太深) B:保证元素的排序方式(具体那种方式取决于使用TreeSet的构造方法) a:自然排序(元素具备比较性) 让元素所属的类实现自然排序 Comparable接口。 示例代码如下: 1 package cn.itcast_06; 2 3 /* 4 * 如果一个类的元素要想能够进行自然排序,就必须实现自然排序接口,然后重写compareTo()方法 5 */ 6 public class Student implements Comparable<Student>{ 7 private String name; 8 private int age; 9 10 public Student() { 11 super(); 12 } 13 14 public Student(String name, int age) { 15 super(); 16 this.name = name; 17 this.age = age; 18 } 19 20 public String getName() { 21 return name; 22 } 23 24 public void setName(String name) { 25 this.name = name; 26 } 27 28 public int getAge() { 29 return age; 30 } 31 32 public void setAge(int age) { 33 this.age = age; 34 } 35 36 @Override 37 public int compareTo(Student s) { 38 // 主要条件:姓名的长度 39 int num = this.name.length() - s.name.length(); 40 // 次要条件1:姓名的长度相同,不代表姓名的内容相同 41 int num2 = (num == 0 ? this.name.compareTo(s.name) : num); 42 // 次要条件2:姓名的长度和内容相同,不代表年龄也相同,所以还得继续比较年龄 43 int num3 = (num2 == 0 ? this.age - s.age : num2); 44 return num3; 45 } 46 47 } Student.java 1 package cn.itcast_06; 2 3 import java.util.TreeSet; 4 5 /* 6 * TreeSet存储自定义对象并保证排序和唯一 7 * 8 * 需求:请按照姓名的长度排序。 9 * 10 * TreeSet集合保证元素排序和唯一性的原理: 11 * 唯一性:是根据比较的返回是否是0来决定。 12 * 排序: 13 * A:自然排序(元素具备比较性) 14 * 让元素所属的类实现自然排序 Comparable接口。 15 * B:比较器排序(集合具备比较性) 16 * 让集合的构造方法接收一个比较器接口 Comparator的实现类对象,一般用匿名内部类实现。 17 */ 18 public class TreeSetDemo { 19 public static void main(String[] args) { 20 // 创建集合对象 21 // TreeSet的构造方法:public TreeSet() // 自然排序 22 TreeSet<Student> ts = new TreeSet<Student>(); 23 24 // 创建元素对象 25 Student s1 = new Student("linqingxia", 27); 26 Student s2 = new Student("zhangguorong", 29); 27 Student s3 = new Student("wanglihong", 23); 28 Student s4 = new Student("linqingxia", 27); 29 Student s5 = new Student("liushishi", 22); 30 Student s6 = new Student("wuqilong", 40); 31 Student s7 = new Student("fengqingy", 22); 32 Student s8 = new Student("linqingxia", 29); 33 34 // 添加元素到集合 35 ts.add(s1); 36 ts.add(s2); 37 ts.add(s3); 38 ts.add(s4); 39 ts.add(s5); 40 ts.add(s6); 41 ts.add(s7); 42 ts.add(s8); 43 44 // 遍历集合 45 for (Student s : ts) { 46 System.out.println(s.getName() + "---" + s.getAge()); 47 } 48 } 49 } TreeSetDemo.java b:比较器排序(集合具备比较性) 让集合的构造方法接收一个比较器接口 Comparator的实现类对象,一般用匿名内部类实现。 示例代码如下: (1)用自己新建的实现类实现 1 package cn.itcast_07; 2 3 /* 4 * 如果一个类的元素要想能够进行比较器排序。 5 */ 6 public class Student { 7 private String name; 8 private int age; 9 10 public Student() { 11 super(); 12 } 13 14 public Student(String name, int age) { 15 super(); 16 this.name = name; 17 this.age = age; 18 } 19 20 public String getName() { 21 return name; 22 } 23 24 public void setName(String name) { 25 this.name = name; 26 } 27 28 public int getAge() { 29 return age; 30 } 31 32 public void setAge(int age) { 33 this.age = age; 34 } 35 36 } Student.java 1 package cn.itcast_07; 2 3 import java.util.Comparator; 4 5 public class MyComparator implements Comparator<Student> { 6 7 @Override 8 public int compare(Student s1, Student s2) { 9 // return 0; 10 11 // 需求:请按照姓名的长度排序 12 // int num = this.name.length() - s.name.length(); 13 // this --> s1 // s1不能直接访问name,因为s1是在MyComparator类中,而name是在Student类中,要想访问,需要通过getXxx()方法 14 // s --> s2 15 16 // 姓名长度 17 int num = s1.getName().length() - s2.getName().length(); 18 // 姓名内容 19 int num2 = (num == 0 ? s1.getName().compareTo(s2.getName()) : num); 20 // 年龄 21 int num3 = (num2 == 0 ? s1.getAge() - s2.getAge() : num2); 22 return num3; 23 } 24 25 } MyComparator.java 1 package cn.itcast_07; 2 3 import java.util.TreeSet; 4 5 /* 6 * 需求:请按照姓名的长度排序 7 * 8 * TreeSet集合保证元素排序和唯一性的原理: 9 * 唯一性:是根据比较的返回是否是0来决定。 10 * 排序: 11 * A:自然排序(元素具备比较性) 12 * 让元素所属的类实现自然排序 Comparable接口。 13 * B:比较器排序(集合具备比较性) 14 * 让集合的构造方法接收一个比较器接口 Comparator的实现类对象,一般用匿名内部类实现。 15 */ 16 public class TreeSetDemo { 17 public static void main(String[] args) { 18 // 创建集合对象 19 // TreeSet的构造方法:public TreeSet(Comparator<? super E> comparator) // 比较器排序,传递的数据类型是引用数据类型中的接口,说明传递的是实现类对象 20 TreeSet<Student> ts = new TreeSet<Student>(new MyComparator()); // 示例:自己写了个具体实现类MyMyComparator,并重写compare()方法 21 22 // 创建元素对象 23 Student s1 = new Student("linqingxia", 27); 24 Student s2 = new Student("zhangguorong", 29); 25 Student s3 = new Student("wanglihong", 23); 26 Student s4 = new Student("linqingxia", 27); 27 Student s5 = new Student("liushishi", 22); 28 Student s6 = new Student("wuqilong", 40); 29 Student s7 = new Student("fengqingy", 22); 30 Student s8 = new Student("linqingxia", 29); 31 32 // 添加元素到集合 33 ts.add(s1); 34 ts.add(s2); 35 ts.add(s3); 36 ts.add(s4); 37 ts.add(s5); 38 ts.add(s6); 39 ts.add(s7); 40 ts.add(s8); 41 42 // 遍历集合 43 for (Student s : ts) { 44 System.out.println(s.getName() + "---" + s.getAge()); 45 } 46 } 47 } TreeSetDemo.java (2)用用匿名内部类实现 1 package cn.itcast_07; 2 3 /* 4 * 如果一个类的元素要想能够进行比较器排序。 5 */ 6 public class Student { 7 private String name; 8 private int age; 9 10 public Student() { 11 super(); 12 } 13 14 public Student(String name, int age) { 15 super(); 16 this.name = name; 17 this.age = age; 18 } 19 20 public String getName() { 21 return name; 22 } 23 24 public void setName(String name) { 25 this.name = name; 26 } 27 28 public int getAge() { 29 return age; 30 } 31 32 public void setAge(int age) { 33 this.age = age; 34 } 35 36 } Student.java 1 package cn.itcast_07; 2 3 import java.util.Comparator; 4 import java.util.TreeSet; 5 6 /* 7 * 需求:请按照姓名的长度排序 8 * 9 * TreeSet集合保证元素排序和唯一性的原理: 10 * 唯一性:是根据比较的返回是否是0来决定。 11 * 排序: 12 * A:自然排序(元素具备比较性) 13 * 让元素所属的类实现自然排序 Comparable接口。 14 * B:比较器排序(集合具备比较性) 15 * 让集合的构造方法接收一个比较器接口 Comparator的实现类对象,一般用匿名内部类实现。 16 */ 17 public class TreeSetDemo { 18 public static void main(String[] args) { 19 // 创建集合对象 20 // TreeSet的构造方法:public TreeSet() // 自然排序 21 // TreeSet<Student> ts = new TreeSet<Student>(); 22 23 // TreeSet的构造方法:public TreeSet(Comparator<? super E> comparator) // 比较器排序,传递的数据类型是引用数据类型中的接口,说明传递的是实现类对象 24 // TreeSet<Student> ts = new TreeSet<Student>(new MyComparator()); // 示例:自己写了个具体实现类MyComparator,并重写compare()方法 25 26 // 如果一个方法的参数是接口,那么真正需要的是接口的实现类的对象,而且该方法只调用一次。 27 // 所以使用匿名内部类就可以实现这个东西,这样就不用自己去重新写一个具体的实现类了。其实这种方式是很常见的。 28 TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() { 29 @Override 30 public int compare(Student s1, Student s2) { 31 // 姓名长度 32 int num = s1.getName().length() - s2.getName().length(); 33 // 姓名内容 34 int num2 = (num == 0 ? s1.getName().compareTo(s2.getName()) : num); 35 // 年龄 36 int num3 = (num2 == 0 ? s1.getAge() - s2.getAge() : num2); 37 return num3; 38 } 39 }); 40 41 // 创建元素对象 42 Student s1 = new Student("linqingxia", 27); 43 Student s2 = new Student("zhangguorong", 29); 44 Student s3 = new Student("wanglihong", 23); 45 Student s4 = new Student("linqingxia", 27); 46 Student s5 = new Student("liushishi", 22); 47 Student s6 = new Student("wuqilong", 40); 48 Student s7 = new Student("fengqingy", 22); 49 Student s8 = new Student("linqingxia", 29); 50 51 // 添加元素到集合 52 ts.add(s1); 53 ts.add(s2); 54 ts.add(s3); 55 ts.add(s4); 56 ts.add(s5); 57 ts.add(s6); 58 ts.add(s7); 59 ts.add(s8); 60 61 // 遍历集合 62 for (Student s : ts) { 63 System.out.println(s.getName() + "---" + s.getAge()); 64 } 65 } 66 } TreeSetDemo.java C:把我们讲过的代码看一遍即可 (4)案例 A:编写一个程序,获取10个1至20的随机数,要求随机数不能重复。 1.用集合HashSet实现 1 package cn.itcast_08; 2 3 import java.util.HashSet; 4 import java.util.Random; 5 6 /* 7 * 编写一个程序,获取10个1至20的随机数,要求随机数不能重复。 8 * 9 * 分析: 10 * A:创建随机数对象 11 * B:创建一个HashSet集合 12 * C:判断集合的长度是不是小于10,因为Integer包装类默认实现了Comparable接口,所以Integer类能自动判断是否有重复元素 13 * 是:就创建一个随机数添加 14 * 否:不搭理它 15 * D:遍历HashSet集合 16 */ 17 public class HashSetDemo { 18 public static void main(String[] args) { 19 // 创建随机数对象 20 Random r = new Random(); 21 22 // 创建一个HashSet集合 23 HashSet<Integer> hs = new HashSet<Integer>(); 24 25 // 判断集合的长度是不是小于10,因为Integer包装类默认实现了Comparable接口,所以Integer类能自动判断是否有重复元素 26 while (hs.size() < 10) { 27 int num = r.nextInt(20) + 1; 28 hs.add(num); 29 } 30 31 // 遍历HashSet集合 32 for (Integer i : hs) { 33 System.out.println(i); 34 } 35 } 36 } HashSetDemo.java 2.用集合ArrayList实现 1 package cn.itcast_02; 2 3 import java.util.ArrayList; 4 import java.util.Random; 5 6 /* 7 * 获取10个1-20之间的随机数,要求不能重复 8 * 9 * 用数组实现,但是数组的长度是固定的。 10 * 长度不好确定,所以我们使用集合实现。 11 * 12 * 分析: 13 * A:创建产生随机数的对象。 14 * B:创建一个存储随机数的集合ArrayList。 15 * C:定义一个统计变量。从0开始。 16 * D:判断统计遍历是否小于10 17 * 是:产生一个随机数,判断该随机数在集合中是否存在。 18 * 如果不存在:就添加,统计变量++。 19 * 如果存在:就不搭理它。 20 * 否:不搭理它 21 * E:遍历ArrayList集合 22 */ 23 public class ArrayListDemo { 24 public static void main(String[] args) { 25 // 创建产生随机数的对象。 26 Random r = new Random(); 27 28 // 创建一个存储随机数的集合。 29 ArrayList<Integer> array = new ArrayList<Integer>(); 30 31 // 定义一个统计变量。从0开始。 32 int count = 0; 33 34 // 判断统计遍历是否小于10 35 while (count < 10) { 36 // 产生一个随机数 37 int number = r.nextInt(20) + 1; 38 39 // 判断该随机数在集合中是否存在。 40 if (!array.contains(number)) { 41 // 如果不存在:就添加,统计变量++。 42 array.add(number); 43 count++; 44 } 45 } 46 47 // 遍历集合 48 for (Integer i : array) { 49 System.out.println(i); 50 } 51 } 52 } ArrayListDemo.java B:键盘录入5个学生信息(姓名、语文成绩、数学成绩、英语成绩),按照总分从高到低输出到控制台。 1 package cn.itcast_09; 2 3 public class Student { 4 // 姓名 5 private String name; 6 // 语文成绩 7 private int chinese; 8 // 数学成绩 9 private int math; 10 // 英语成绩 11 private int english; 12 13 public Student() { 14 super(); 15 } 16 17 public Student(String name, int chinese, int math, int english) { 18 super(); 19 this.name = name; 20 this.chinese = chinese; 21 this.math = math; 22 this.english = english; 23 } 24 25 public String getName() { 26 return name; 27 } 28 29 public void setName(String name) { 30 this.name = name; 31 } 32 33 public int getChinese() { 34 return chinese; 35 } 36 37 public void setChinese(int chinese) { 38 this.chinese = chinese; 39 } 40 41 public int getMath() { 42 return math; 43 } 44 45 public void setMath(int math) { 46 this.math = math; 47 } 48 49 public int getEnglish() { 50 return english; 51 } 52 53 public void setEnglish(int english) { 54 this.english = english; 55 } 56 57 public int getSum() { 58 return this.chinese + this.math + this.english; 59 } 60 } Student.java 1 package cn.itcast_09; 2 3 import java.util.Comparator; 4 import java.util.Scanner; 5 import java.util.TreeSet; 6 7 /* 8 * 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台 9 * 10 * 分析: 11 * A:定义学生类 12 * B:创建一个TreeSet集合 13 * C:总分从高到底如何实现呢? 14 * D:键盘录入5个学生信息 15 * E:遍历TreeSet集合 16 */ 17 public class TreeSetDemo { 18 public static void main(String[] args) { 19 // 创建一个TreeSet集合 20 TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() { 21 @Override 22 public int compare(Student s1, Student s2) { 23 // 总分从高到低 24 int num = s2.getSum() - s1.getSum(); 25 // 总分相同的不一定语文相同 26 int num2 = (num == 0 ? s1.getChinese() - s2.getChinese() : num); 27 // 总分和语文相同的不一定数序相同 28 int num3 = (num2 == 0 ? s1.getMath() - s2.getMath() : num2); 29 // 总分、语文和数学相同的不一定英语相同 30 int num4 = (num3 == 0 ? s1.getEnglish() - s2.getEnglish() : num3); 31 // 总分、语文、数学和英语相同的姓名还不一定相同 32 int num5 = (num4 == 0 ? s1.getName().compareTo(s2.getName()) : num4); 33 return num5; 34 } 35 }); 36 37 System.out.println("学生信息录入开始"); 38 // 键盘录入5个学生信息 39 for (int x = 1; x <= 5; x++) { 40 Scanner sc = new Scanner(System.in); 41 42 System.out.println("请输入第" + x + "个学生的姓名:"); 43 String name = sc.nextLine(); 44 45 System.out.println("请输入第" + x + "个学生的语文成绩:"); 46 String chineseString = sc.nextLine(); 47 48 System.out.println("请输入第" + x + "个学生的数学成绩:"); 49 String mathString = sc.nextLine(); 50 51 System.out.println("请输入第" + x + "个学生的英语成绩:"); 52 String englishString = sc.nextLine(); 53 54 // 把录入的数据封装到学生对象中 55 Student s = new Student(); 56 s.setName(name); 57 s.setChinese(Integer.parseInt(chineseString)); // 把字符串类型转换为int类型 58 s.setMath(Integer.parseInt(mathString)); // 把字符串类型转换为int类型 59 s.setEnglish(Integer.parseInt(englishString)); // 把字符串类型转换为int类型 60 61 // 把学生对象添加到集合 62 ts.add(s); 63 } 64 System.out.println("学生信息录入完毕"); 65 66 System.out.println("学习信息从高到低排序如下:"); 67 System.out.println("姓名\t语文成绩\t数学成绩\t英语成绩"); 68 // 遍历TreeSet集合 69 for (Student s : ts) { 70 System.out.println(s.getName() + "\t" + s.getChinese() + "\t" + s.getMath() + "\t" + s.getEnglish()); 71 } 72 } 73 } TreeSetDemo.java ----------------------------------------------------------------------------- 3:Collection集合总结(掌握) Collection |--List 有序,元素可重复 |--ArrayList 底层数据结构是数组。查询快,增删慢。 线程不安全,效率高 |--Vector 底层数据结构是数组。查询快,增删慢。 线程安全,效率低 |--LinkedList 底层数据结构是链表。查询慢,增删快。 线程不安全,效率高 |--Set 无序,元素唯一 |--HashSet 底层数据结构是哈希表。 如何保证元素唯一性的呢? 依赖两个方法:hashCode()和equals() 开发中自动生成这两个方法即可。 |--LinkedHashSet 底层数据结构是链表和哈希表。 由链表保证元素有序。 由哈希表保证元素唯一。 |--TreeSet 底层数据结构是红黑树(二叉树)。 如何保证元素排序的呢? 自然排序 比较器排序 如何保证元素唯一性的呢? 根据比较的返回值是否是0来决定。 ----------------------------------------------------------------------------- 4:针对Collection集合我们到底使用谁呢?(掌握) 元素唯一吗? 是:用Set 元素排序吗? 是:TreeSet 否:HashSet 如果你知道是用Set,但是不知道是用哪个Set,就用HashSet。 否:用List 要安全吗? 是:Vector 否:ArrayList 或者 LinkedList 查询多:ArrayList 增删多:LinkedList 如果你知道是用List,但是不知道是用哪个List,就用ArrayList。 --------------------------------------- 如果你知道是用 Collection 集合,但是不知道使用谁,就用 ArrayList。 如果你仅仅知道用集合,就用ArrayList。 由此可见,ArrayList用的最多。 ----------------------------------------------------------------------------- 5:在集合中常见的数据结构(掌握) ArrayXxx: 底层数据结构是数组,查询快,增删慢。 LinkedXxx: 底层数据结构是链表,查询慢,增删快。 HashXxx: 底层数据结构是哈希表。依赖两个方法:hashCode()和equals()。 TreeXxx: 底层数据结构是二叉树。两种方式排序:自然排序和比较器排序。============================================================================= 我的GitHub地址: https://github.com/heizemingjun 我的博客园地址: http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址: http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军 【转载文章务必保留出处和署名,谢谢!】

优秀的个人博客,低调大师

java基础学习_常用类03_StringBuffer类、数组高级和Arrays类、Integer类和Character类_day13总结

==========================================================================================================================================================涉及到的知识点有:1:StringBuffer类的概述及其使用(掌握) (1)StringBuffer类的概述 (2)StringBuffer类的构造方法 (3)StringBuffer类的常见功能 (4)StringBuffer类的练习(做一遍) (5)StringBuffer类的两个面试题 (6)StringBuffer类作为形式参数的问题2:数组高级以及Arrays类的概述及其使用(掌握) (1)数组排序 A:冒泡排序 B:选择排序 (2)数组查找 A:基本查找 B:二分查找(折半查找) (3)Arrays工具类 (4)Arrays工具类的源码解析3:Integer类(掌握) (1)Integer类的概述 (2)Integer类的构造方法 (3)String引用数据类型和int基本数据类型的相互转换(推荐方法) (4)Integer类的成员方法 (5)Integer类的其他的功能(了解) (6)JDK5的新特性:自动装箱和自动拆箱 (7)Integer类的面试题4:Character类(了解) (1)Character类的概述 (2)Character类的构造方法 (3)Character类要掌握的方法 (4)Character类的案例==========================================================================================================================================================1:StringBuffer类的概述及其使用(掌握) (1)StringBuffer类的概述 我们用字符串做拼接,每次拼接,都会构建一个新的String对象,比较耗时并且也耗内存。 而这种拼接操作又是比较常见的,为了解决这个问题,Java就提供了一个字符串缓冲区类StringBuffer供我们使用。 StringBuffer:是线程安全的可变字符串(字符序列)。 线程安全(多线程讲解) 安全 --> 同步 --> 数据是安全的 不安全 --> 不同步 --> 效率高一些 安全和效率问题是永远困扰我们的问题。 要安全:医院的网站,银行网站等等。 要效率:新闻网站,论坛之类等等。 StringBuffer和String的区别? StringBuffer的长度和内容可变,String的不可变。 如果使用StringBuffer做字符串的拼接,不会浪费太多的资源。--------------------------------------- (2)StringBuffer类的构造方法 A:public StringBuffer() 无参构造方法 B:public StringBuffer(int capacity) 指定容量的字符串缓冲区对象 C:public StringBuffer(String str) 指定字符串内容的字符串缓冲区对象 D:public StringBuffer(CharSequence seq) CharSequence是接口,其所有已知实现类:CharBuffer, Segment, String, StringBuffer, StringBuilder E:StringBuffer的方法: public int capacity() 返回当前容量。 理论值 public int length() 返回长度(字符数)。 实际值--------------------------------------- (3)StringBuffer类的常见功能 A:添加功能 public StringBuffer append(String str) 可以把任意类型数据添加到字符串缓冲区里面,并返回字符串缓冲区对象本身,所以不需要再去创建对象接收了(该点很重要)。 public StringBuffer insert(int offset, String str) 在指定位置把任意类型数据插入到字符串缓冲区里面,并返回字符串缓冲区对象本身。 B:删除功能 public StringBuffer deleteCharAt(int index) 删除指定位置的字符,并返回字符串缓冲区对象本身。 public StringBuffer delete(int start, int end) 删除从指定位置开始到指定位置结束的内容,并返回字符串缓冲区对象本身(包头不包尾)。 C:替换功能 public StringBuffer replace(int start, int end, String str) 从start开始到end用str替换,并返回字符串缓冲区对象本身(包头不包尾)。 D:反转功能 public StringBuffer reverse() 反转字符串缓冲区内容,并返回字符串缓冲区对象本身。 E:截取功能(注意返回值类型不再是StringBuffer对象本身了) public String substring(int start) 从指定位置开始截取字符串,默认到末尾(包含start这个索引),返回的是字符串对象。 public String substring(int start, int end) 从指定位置开始到指定位置结束截取字符串(包括start索引但是不包end索引),返回的是字符串对象。--------------------------------------- (4)StringBuffer类的练习(做一遍) 为什么我们要讲解类之间的转换? A --> B的转换 我们把A转换为B,其实是为了使用B的功能。 B --> A的转换 我们可能要的结果是A类型,所以还得转换回来。--------------------------------------- A:String类和StringBuffer类的相互转换 String --> StringBuffer 方式1:通过StringBuffer类的构造方法(推荐) String s = "hello"; StringBuffer sb = new StringBuffer(s); 方式2:通过StringBuffer类的append()方法 String s = "hello"; StringBuffer sb2 = new StringBuffer(); sb2.append(s);--------------------------------------- StringBuffer --> String 方式1:通过String类的构造方法 StringBuffer buffer = new StringBuffer("java"); String str = new String(buffer); 方式2:通过StringBuffer类的toString()方法(推荐) StringBuffer buffer = new StringBuffer("java"); String str2 = buffer.toString();--------------------------------------- 注意:不能把字符串的值直接赋值给StringBuffer的。 StringBuffer sb = "hello"; StringBuffer sb = s;--------------------------------------- B:把数组拼接成一个字符串 示例代码如下: 1 package cn.itcast_07; 2 3 /* 4 * 把数组拼接成一个字符串 5 */ 6 public class StringBufferTest2 { 7 public static void main(String[] args) { 8 // 定义一个数组 9 int[] arr = { 44, 33, 55, 11, 22 }; 10 11 // 定义功能 12 // 方式1:用String做拼接的方式,开辟内存特别多,效率低。 13 String s1 = arrayToString(arr); 14 System.out.println("s1:" + s1); 15 16 // 方式2:用StringBuffer做拼接的方式 17 String s2 = arrayToString2(arr); 18 System.out.println("s2:" + s2); 19 } 20 21 // 用StringBuffer做拼接的方式 22 public static String arrayToString2(int[] arr) { 23 StringBuffer sb = new StringBuffer(); 24 25 sb.append("["); 26 for (int x = 0; x < arr.length; x++) { 27 if (x == arr.length - 1) { 28 sb.append(arr[x]); 29 } else { 30 sb.append(arr[x]).append(", "); 31 } 32 } 33 sb.append("]"); 34 35 return sb.toString(); // StringBuffer --> String 36 } 37 38 // 用String做拼接的方式 39 public static String arrayToString(int[] arr) { 40 String s = ""; 41 42 s += "["; 43 for (int x = 0; x < arr.length; x++) { 44 if (x == arr.length - 1) { 45 s += arr[x]; 46 } else { 47 s += arr[x]; 48 s += ", "; 49 } 50 } 51 s += "]"; 52 53 return s; 54 } 55 } C:把字符串反转 示例代码如下: 1 package cn.itcast_07; 2 3 import java.util.Scanner; 4 5 /* 6 * 把字符串反转 7 */ 8 public class StringBufferTest3 { 9 public static void main(String[] args) { 10 // 键盘录入数据 11 Scanner sc = new Scanner(System.in); 12 System.out.println("请输入数据:"); 13 String s = sc.nextLine(); 14 15 // 方式1:用String做拼接 16 String s1 = myReverse(s); 17 System.out.println("s1:" + s1); 18 // 方式2:用StringBuffer的reverse()的反转功能 19 String s2 = myReverse2(s); 20 System.out.println("s2:" + s2); 21 22 sc.close(); 23 } 24 25 // 方式2:用StringBuffer的reverse()的反转功能 26 public static String myReverse2(String s) { 27 // StringBuffer sb = new StringBuffer(s); 28 // sb.reverse(); 29 // return sb.toString(); 30 31 // 简易版 32 return new StringBuffer(s).reverse().toString(); 33 } 34 35 // 方式1:用String做拼接 36 public static String myReverse(String s) { 37 String result = ""; 38 39 char[] chs = s.toCharArray(); // 把字符串转换为字符数组 40 for (int x = chs.length - 1; x >= 0; x--) { 41 // char ch = chs[x]; // 得到每一个字符 42 // result += ch; 43 result += chs[x]; 44 } 45 46 return result; 47 } 48 } D:判断一个字符串是否是对称字符串 示例代码如下: 1 package cn.itcast_07; 2 3 import java.util.Scanner; 4 5 /* 6 * 判断一个字符串是否是对称字符串 7 * 例如"abc"不是对称字符串,"aba"、"abba"、"aaa"、"mnanm"是对称字符串 8 * 9 * 分析: 10 * 判断一个字符串是否是对称的字符串,我只需要把 11 * 第一个和最后一个比较 12 * 第二个和倒数第二个比较 13 * ... 14 * 比较的次数是长度除以2。 15 */ 16 public class StringBufferTest4 { 17 public static void main(String[] args) { 18 // 创建键盘录入对象 19 Scanner sc = new Scanner(System.in); 20 System.out.println("请输入一个字符串:"); 21 String s = sc.nextLine(); 22 23 // 一个一个的比较 24 boolean b = isSame(s); 25 System.out.println("b:" + b); 26 27 // 用字符串缓冲区的反转功能 28 boolean b2 = isSame2(s); 29 System.out.println("b2:"+b2); 30 31 sc.close(); 32 } 33 34 public static boolean isSame2(String s) { 35 return new StringBuffer(s).reverse().toString().equals(s); 36 } 37 38 39 // public static boolean isSame(String s) { 40 // // 把字符串转成字符数组 41 // char[] chs = s.toCharArray(); 42 // 43 // for (int start = 0, end = chs.length - 1; start <= end; start++, end--) { 44 // if (chs[start] != chs[end]) { 45 // return false; 46 // } 47 // } 48 // 49 // return true; 50 // } 51 52 public static boolean isSame(String s) { 53 boolean flag = true; 54 55 // 把字符串转成字符数组 56 char[] chs = s.toCharArray(); 57 for (int start = 0, end = chs.length - 1; start <= end; start++, end--) { 58 if (chs[start] != chs[end]) { 59 flag = false; 60 break; 61 } 62 } 63 64 return flag; 65 } 66 67 } --------------------------------------- (5)StringBuffer类的两个面试题 小细节: StringBuffer 同步的,数据安全,效率低。 StringBuilder 不同步的,数据不安全,效率高。 StringBuilder是一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API,但不保证同步。 该类被设计用作 StringBuffer 的一个简易替换,用在字符串缓冲区被单个线程使用的时候(这种情况很普遍)。 A:String、StringBuffer、StringBuilder的区别? a:String是内容不可变的,而StringBuffer、StringBuilder都是内容可变的。 b:StringBuffer是同步的,数据安全,效率低;StringBuilder是不同步的,数据不安全,效率高。 B:StringBuffer和数组的区别? 二者都可以看出是一个容器,装其他的数据。 但是呢,StringBuffer可以放置多种数据,但最终是一个字符串数据。 而数组可以放置多种数据,但必须是同一种数据类型的。 (6)StringBuffer类作为形式参数的问题: String类作为形式参数。 StringBuffer类作为形式参数。 形式参数: 基本数据类型:形式参数的改变不影响实际参数。 引用数据类型:形式参数的改变直接影响实际参数。 String类作为形式参数传递时,效果和基本数据类型作为形式参数传递是一样的。 示例代码如下: 1 package cn.itcast_08; 2 3 /* 4 * 面试题: 5 * 1:String、StringBuffer、StringBuilder的区别? 6 * A:String是内容不可变的,而StringBuffer、StringBuilder都是内容可变的。 7 * B:StringBuffer是同步的,数据安全,效率低;StringBuilder是不同步的,数据不安全,效率高。 8 * 9 * 2:StringBuffer和数组的区别? 10 * 二者都可以看出是一个容器,装其他的数据。 11 * 但是呢,StringBuffer可以放置多种数据,但最终是一个字符串数据。 12 * 而数组可以放置多种数据,但必须是同一种数据类型的。 13 * 14 * 3:形式参数问题 15 * String类作为参数传递 16 * StringBuffer类作为参数传递 17 * 18 * 形式参数: 19 * 基本数据类型:形式参数的改变不影响实际参数。 20 * 引用数据类型:形式参数的改变直接影响实际参数。 21 * 22 * 注意: 23 * String类作为形式参数传递时,效果和基本数据类型作为形式参数传递是一样的。 24 */ 25 public class StringBufferDemo { 26 public static void main(String[] args) { 27 String s1 = "hello"; 28 String s2 = "world"; 29 System.out.println(s1 + "---" + s2); // hello---world 30 change(s1, s2); 31 System.out.println(s1 + "---" + s2); // hello---world 32 33 StringBuffer sb1 = new StringBuffer("hello"); 34 StringBuffer sb2 = new StringBuffer("world"); 35 System.out.println(sb1 + "---" + sb2); // hello---world 36 change(sb1, sb2); 37 System.out.println(sb1 + "---" + sb2); // hello---worldworld 38 } 39 40 public static void change(StringBuffer sb1, StringBuffer sb2) { 41 sb1 = sb2; // sb1的地址值由于赋值临时发生改变,但在main函数里面的sb1的地址值没有变。 42 sb2.append(sb1); // append函数使sb2的内容发生改变,但在main函数里面的sb2的地址值没有变。即通过change函数里面的append函数sb2指向的内容发生改变。 43 } 44 45 public static void change(String s1, String s2) { 46 s1 = s2; // sb1的地址值由于赋值临时发生改变,但在main函数里面的sb1的地址值没有变。 47 s2 = s1 + s2; // sb2的地址值由于赋值临时发生改变,但在main函数里面的sb2的地址值没有变。 48 } 49 } ----------------------------------------------------------------------------- 2:数组高级以及Arrays类的概述及其使用(掌握) (1)数组排序 A:冒泡排序 相邻元素两两比较,大的往后放,第一次比较完毕,最大值出现在了最大索引处。同理,其他的元素就可以排好。01_数组冒泡排序原理图解如下图所示: public static void bubbleSort(int[] arr) { for (int x = 0; x < arr.length - 1 ; x++) { for (int y = 0; y < arr.length - 1 - x; y++) { if (arr[y] > arr[y+1]) { int temp = arr[y]; arr[y] = arr[y+1]; arr[y+1] = temp; } } } } B:选择排序 把0索引的元素,依次和后面的元素进行比较,小的往前放,第一次比较完毕,最小值出现在了0索引。同理,其他的元素就可以排好。02_数组选择排序原理图解如下图所示: public static void selectSort(int[] arr) { for (int x = 0; x < arr.length - 1; x++) { for (int y = x + 1; y < arr.length; y++) { if (arr[y] < arr[x]) { int temp = arr[x]; arr[x] = arr[y]; arr[y] = temp; } } } } 练习:把字符串中的字符进行排序。 示例代码如下: 1 package cn.itcast_03; 2 3 /* 4 * 把字符串中的字符进行排序。 5 * 举例:"dacgebf" 6 * 结果:"abcdefg" 7 * 8 * 分析: 9 * A:定义一个字符串 10 * B:把字符串转换为字符数组 11 * C:把字符数组进行排序 12 * D:把排序后的字符数组转成字符串 13 * E:输出最后的字符串 14 */ 15 public class ArrayTest { 16 public static void main(String[] args) { 17 // 定义一个字符串 18 String s = "dacgebf"; 19 20 // 把字符串转换为字符数组 21 char[] chs = s.toCharArray(); 22 23 // 把字符数组进行排序 24 bubbleSort(chs); 25 26 // 把排序后的字符数组转成字符串 27 String result = String.valueOf(chs); 28 29 // 输出最后的字符串 30 System.out.println("result:"+result); 31 } 32 33 // 冒泡排序 34 public static void bubbleSort(char[] chs) { 35 for (int x = 0; x < chs.length - 1; x++) { 36 for (int y = 0; y < chs.length - 1 - x; y++) { 37 if (chs[y] > chs[y + 1]) { 38 char temp = chs[y]; 39 chs[y] = chs[y + 1]; 40 chs[y + 1] = temp; 41 } 42 } 43 } 44 } 45 } --------------------------------------- (2)数组查找 A:基本查找 针对数组无序的情况 public static int getIndex(int[] arr, int value) { int index = -1; for (int x = 0; x < arr.length; x++) { if (arr[x] == value) { index = x; break; } } return index; } B:二分查找(折半查找) 针对数组有序的情况(千万不要先将无须数组排序,再查找,无序数组就用基本查找法) A:定义最大索引,最小索引; B:计算出中间索引; C:拿中间索引的值和要查找的值进行比较: 相等:就返回当前的中间索引。 不相等: 大 左边找 小 右边找 D:重新计算出中间索引: 大 左边找 max = mid - 1; 小 右边找 min = mid + 1; E:回到B。 public static int binarySearch(int[] arr, int value) { int min = 0; int max = arr.length - 1; int mid = (min + max) / 2; while (arr[mid] != value) { if (arr[mid] > value) { max = mid - 1; } else if (arr[mid] < value) { min = mid + 1; } if (min > max) { return -1; } mid = (min+max) / 2; } return mid; } --------------------------------------- (3)Arrays工具类 A:是针对数组进行操作的工具类。包括排序和查找等功能(注意:该类没有构造方法,都是静态的方法,通过类名调用。) B:要掌握的方法(自己补齐方法) 1:public static String toString(int[] a) 把数组转成字符串(数组可以是任何类型的数组哦) 2:public static void sort(int[] a) 对数组进行排序 3:public static int binarySearch(int[] a, int key) 二分查找 (4)Arrays工具类的源码解析 Arrays类的底层排序方法是快速排序。 能用JDK提供的就不用自己写的,因为JDK提供的会做很多优化。--------------------------------------- --------------------------------------- public static String toString(int[] a) public static void sort(int[] a) 底层是快速排序,知道就可以了。有空看,有问题再问我。 public static int binarySearch(int[] a,int key) 开发原则: 只要是形参是对象,我们就要首先判断该对象是否为null。 也即只要是形参是引用数据类型,我们就要首先判断该数据类型是否为null。 --------------------------------------- int[] arr = { 24, 69, 80, 57, 13 }; System.out.println("排序前:" + Arrays.toString(arr)); public static String toString(int[] a) { //a --> arr --> { 24, 69, 80, 57, 13 } if (a == null) return "null"; // 说明数组对象不存在。 int iMax = a.length - 1; // iMax = 5 - 1 = 4; if (iMax == -1) return "[]"; // 说明数组存在,但是没有元素。 StringBuilder b = new StringBuilder(); b.append('['); // "[" for (int i = 0; ; i++) { // 第二个条件不写,默认为true。 b.append(a[i]); // "[24, 69, 80, 57, 13" if (i == iMax) return b.append(']').toString(); // "[24, 69, 80, 57, 13]" b.append(", "); // "[24, 69, 80, 57, " } } --------------------------------------- int[] arr = { 13, 24, 57, 69, 80 }; System.out.println("binarySearch:" + Arrays.binarySearch(arr, 577)); public static int binarySearch(int[] a, int key) { // a --> arr --> { 13, 24, 57, 69, 80 } // key --> 577 return binarySearch0(a, 0, a.length, key); } private static int binarySearch0(int[] a, int fromIndex, int toIndex, int key) { // a --> arr --> { 13, 24, 57, 69, 80 } // fromIndex --> 0 // toIndex --> 5 // key --> 577 int low = fromIndex; // low=0 int high = toIndex - 1; // high=4 while (low <= high) { // 无符号右移一位,相当于除以2。 int mid = (low + high) >>> 1; // mid=2,mid=3,mid=4 int midVal = a[mid]; // midVal=57,midVal=69,midVal=80 if (midVal < key) low = mid + 1; // low=3,low=4,low=5 else if (midVal > key) high = mid - 1; else return mid; // key found } return -(low + 1); // key not found. } --------------------------------------- -----------------------------------------------------------------------------3:Integer类(掌握) (1)Integer类的概述 为了对基本数据类型进行更多的操作,更方便的操作,Java就针对每一种基本数据类型提供了对应的类类型。包装类类型。 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。 简言之:只有我们把某个东西看成一个类的时候,我们使用这个东西的功能和属性的时候就特别方便。 常用的操作之一:用于基本数据类型与字符串之间的转换。 基本数据类型 引用数据类型 byte Byte short Short int Integer long Long float Float double Double char Character boolean Boolean --------------------------------------- (2)Integer类的构造方法 public Integer(int value) Integer i = new Integer(100); 很少使用这个构造函数。 静态工厂valueOf(int)通常是一个更好的选择,因为它可能产生明显更好的空间和时间性能。 public Integer(String s) Integer i = new Integer("100"); 很少使用这个构造函数。 使用parseInt(String)将字符串转换为int原语,或使用valueOf(String)将字符串转换为Integer对象。 注意:这里的字符串必须是由数字字符组成的。--------------------------------------- (3)String引用数据类型和int基本数据类型的相互转换(推荐方法) A:String --> int Integer.parseInt("100"); B:int --> String String.valueOf(100); 示例代码如下: 1 package cn.itcast_03; 2 3 /* 4 * String引用数据类型和int基本数据类型的相互转换 5 * 6 * int --> String 7 * String.valueOf(number) 8 * 9 * String --> int 10 * Integer.parseInt(s) 11 */ 12 public class IntegerDemo { 13 public static void main(String[] args) { 14 // int --> String 15 int number = 100; 16 // 方式1:字符串的拼接 17 String s1 = "" + number; 18 System.out.println("s1:" + s1); 19 // 方式2:String类的valueof方法 20 String s2 = String.valueOf(number); 21 System.out.println("s2:" + s2); 22 // 方式3:通过Integer作为桥梁 23 // int --> Integer --> String 24 Integer i = new Integer(number); 25 String s3 = i.toString(); 26 System.out.println("s3:" + s3); 27 // 方式4:Integer类的toString方法 28 // public static String toString(int i) 29 String s4 = Integer.toString(number); 30 System.out.println("s4:" + s4); 31 System.out.println("-----------------"); 32 33 // String --> int 34 String s = "100"; 35 // 方式1:通过Integer作为桥梁 36 // String --> Integer --> int 37 Integer ii = new Integer(s); 38 // public int intValue() 39 int x = ii.intValue(); 40 System.out.println("x:" + x); 41 // 方式2:Integer类的parseInt方法 42 // public static int parseInt(String s) 43 int y = Integer.parseInt(s); 44 System.out.println("y:"+y); 45 } 46 } --------------------------------------- (4)Integer类的成员方法 public int intValue() public static int parseInt(String s) public static String toString(int i) public static Integer valueOf(int i) public static Integer valueOf(String s)--------------------------------------- (5)Integer类的其他的功能(了解) 常用的基本进制转换:十进制到二进制、八进制、十六进制 public static String toBinaryString(int i) public static String toOctalString(int i) public static String toHexString(int i) 十进制到其他进制 public static String toString(int i, int radix) 进制的范围:2-36 为什么呢?0,...9,a...z 其他进制到十进制 public static int parseInt(String s, int radix) 示例代码如下: 1 package cn.itcast_04; 2 3 /* 4 * 常用的基本进制转换 5 * public static String toBinaryString(int i) 6 * public static String toOctalString(int i) 7 * public static String toHexString(int i) 8 * 9 * 十进制到其他进制 10 * public static String toString(int i, int radix) 11 * 由这个我们也看到了进制的范围:2-36 12 * 为什么呢?0,...9,a...z 13 * 14 * 其他进制到十进制 15 * public static int parseInt(String s, int radix) 16 */ 17 public class IntegerDemo { 18 public static void main(String[] args) { 19 // 十进制到二进制、八进制、十六进制 20 System.out.println(Integer.toBinaryString(100)); //1100100 21 System.out.println(Integer.toOctalString(100)); //144 22 System.out.println(Integer.toHexString(100)); //64 23 System.out.println("-------------------------"); 24 25 // 十进制到其他进制 26 System.out.println(Integer.toString(100, 10)); // 100 27 System.out.println(Integer.toString(100, 2)); // 1100100 28 System.out.println(Integer.toString(100, 8)); // 144 29 System.out.println(Integer.toString(100, 16)); // 64 30 System.out.println(Integer.toString(100, 5)); // 400 31 System.out.println(Integer.toString(100, 7)); // 202 32 System.out.println(Integer.toString(100, -7)); // 100 33 System.out.println(Integer.toString(100, 70)); // 100 34 System.out.println(Integer.toString(100, 1)); // 100 35 System.out.println(Integer.toString(100, 17)); // 5f 36 System.out.println(Integer.toString(100, 32)); // 34 37 System.out.println(Integer.toString(100, 37)); // 100 38 System.out.println(Integer.toString(100, 36)); // 2s 39 System.out.println("-----------------------"); 40 41 // 其他进制到十进制 42 System.out.println(Integer.parseInt("100", 10)); // 100 43 System.out.println(Integer.parseInt("100", 2)); // 4 44 System.out.println(Integer.parseInt("100", 8)); // 64 45 System.out.println(Integer.parseInt("100", 16)); // 256 46 System.out.println(Integer.parseInt("100", 23)); // 529 47 // NumberFormatException 48 // System.out.println(Integer.parseInt("123", 2)); 49 } 50 } --------------------------------------- (6)JDK5的新特性:自动装箱和自动拆箱 自动装箱:把基本数据类型转换为包装类数据类型。 自动拆箱:把包装类数据类型转换为基本数据类型。 把下面的这个代码理解即可: Integer i = 100; i += 200; System.out.println("ii:" + ii); // 上面三句,通过反编译后的代码如下: // Integer ii = Integer.valueOf(100); // 自动装箱 // ii = Integer.valueOf(ii.intValue() + 200); // 自动拆箱,再自动装箱 // System.out.println((new StringBuilder("ii:")).append(ii).toString()); 示例代码如下: package cn.itcast_05; /* * JDK5的新特性: * 自动装箱:把基本数据类型转换为包装类数据类型。 * 自动拆箱:把包装类数据类型转换为基本数据类型。 * * 注意一个小问题: * 在使用时,Integer x = null; 代码就会出现NullPointerException。 * 在使用Integer类的对象的时候,建议先判断该对象是否为null,然后再使用。 */ public class IntegerDemo { public static void main(String[] args) { // 定义了一个int类型的包装类类型变量i // Integer i = new Integer(100); // 等价于下面这句 Integer ii = 100; ii += 200; System.out.println("ii:" + ii); // 通过反编译后的代码 // Integer ii = Integer.valueOf(100); // 自动装箱 // ii = Integer.valueOf(ii.intValue() + 200); // 自动拆箱,再自动装箱 // System.out.println((new StringBuilder("ii:")).append(ii).toString()); /* Integer iii = null; // NullPointerException 因为通过反编译可以知道,iii是对象要调用方法,但iii是空指针。 if (iii != null) { iii += 1000; System.out.println(iii); } */ } } --------------------------------------- (7)Integer类的面试题 byte常量池,即-128到127之间的数据缓冲池问题。 这句 Integer i = 100; 等价于 Integer ii = Integer.valueOf(100); // 自动装箱 通过查看valueOf方法的源码,我们就知道了,当Integer类型的数据直接赋值时,如果在-128到127之间,会直接从缓冲池里获取数据,每次并不创建新的空间。-----------------------------------------------------------------------------4:Character类(了解) (1)Character类的概述 Character 类在对象中包装一个基本类型 char 的值 此外,该类提供了几种方法,以确定字符的类别(小写字母,数字,等等),并将字符从大写转换成小写,反之亦然。 (2)Character类的构造方法 Character ch = new Character('a'); 很少使用这个构造函数。 静态工厂valueOf(char)通常是一个更好的选择,因为它可能产生明显更好的空间和时间性能。 (3)Character类要掌握的方法:(自己补齐) public static boolean isUpperCase(char ch) 判断给定的字符是否是大写字符 public static boolean isLowerCase(char ch) 判断给定的字符是否是小写字符 public static boolean isDigit(char ch) 判断给定的字符是否是数字字符 public static char toUpperCase(char ch) 把给定的字符转换为大写字符 public static char toLowerCase(char ch) 把给定的字符转换为小写字符 (4)Character类的案例: 统计字符串中大写、小写及数字字符出现的次数。 示例代码如下: 1 package cn.itcast_06; 2 3 /* 4 * 看程序写结果 5 * 6 * 注意:当Integer类型的数据直接赋值时,如果在-128到127之间,会直接从缓冲池里获取数据,每次并不创建新的空间。 7 */ 8 public class IntegerDemo { 9 public static void main(String[] args) { 10 Integer i1 = new Integer(127); 11 Integer i2 = new Integer(127); 12 System.out.println(i1 == i2); // false 13 System.out.println(i1.equals(i2)); // true 14 System.out.println("-----------"); 15 16 Integer i3 = new Integer(128); 17 Integer i4 = new Integer(128); 18 System.out.println(i3 == i4); // false 19 System.out.println(i3.equals(i4)); // true 20 System.out.println("-----------"); 21 22 // JDK5的新特性 23 Integer i5 = 128; 24 Integer i6 = 128; 25 System.out.println(i5 == i6); // false 重新new出来的。 26 System.out.println(i5.equals(i6)); // true 27 System.out.println("-----------"); 28 29 Integer i7 = 127; 30 Integer i8 = 127; 31 System.out.println(i7 == i8); // true 缓冲池中来的(byte常量池)。 32 System.out.println(i7.equals(i8)); // true 33 34 // 通过查看源码,我们就知道了,针对-128到127之间的数据,做了一个数据缓冲池,如果数据是该范围内的,则每次并不创建新的空间。 35 // Integer ii = Integer.valueOf(127); 36 } 37 } =============================================================================我的GitHub地址: https://github.com/heizemingjun 我的博客园地址: http://www.cnblogs.com/chenmingjun 我的蚂蚁笔记博客地址: http://blog.leanote.com/chenmingjun Copyright ©2018 黑泽明军 【转载文章务必保留出处和署名,谢谢!】

资源下载

更多资源
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长,特征是大鼻子、头戴帽子、身穿背带裤,还留着胡子。与他的双胞胎兄弟路易基一起,长年担任任天堂的招牌角色。

腾讯云软件源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题,腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构,目前腾讯云软件源站支持公网访问和内网访问。

Nacos

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称,一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集,帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能,例如代码缩略图,Python的插件,代码段等。还可自定义键绑定,菜单和工具栏。Sublime Text 的主要功能包括:拼写检查,书签,完整的 Python API , Goto 功能,即时项目切换,多选择,多窗口等等。Sublime Text 是一个跨平台的编辑器,同时支持Windows、Linux、Mac OS X等操作系统。

用户登录
用户注册
修改密码
忘记密码