@YanM
@YanM

java8新特性

Lambda表达式

有以下代码：

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("新线程中执行的代码"+Thread.currentThread().getName());
    }
}).start();

代码分析:

  1. Thread类需要一个Runnable接口作为参数，其中的抽象方法run方法是用来指定线程任务内容的核心；
  2. 为了指定run方法体，不得不需要Runnable的实现类；
  3. 为了省去定义一个Runnable 的实现类，不得不使用匿名内部类；
  4. 必须覆盖重写抽象的run方法，所有的方法名称，方法参数，方法返回值不得不都重写一遍，而且不能出错；
  5. 而实际上，我们只在乎方法体中的代码。

 上面代码可以写成lambda形式如下：

new Thread(()->{
    System.out.println("lambda表达式新线程"+Thread.currentThread().getName());
}).start();

Lambda表达式是一个匿名函数，可以理解为一段可以传递的代码。

lambda运行就是将函数作为一个参数传递到方法中。用以简化接口的使用，让代码更加简洁。

lambda的基础语法：

(参数类型 参数1,参数类型 参数2,...)->{

        代码体;

}

格式1：无参，无返回值

public interface UserService {
    void show();
}
public class Demo02Lambda {
    public static void main(String[] args) {
        goShow(new UserService() {
            @Override
            public void show() {
                System.out.println("show方法执行了");
            }
        });
        goShow(()->{
            System.out.println("lambda show方法执行了");
        });
    }
    public static void goShow(UserService userService){
        userService.show();
    }
}

格式2：有参且有返回值的

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {
    private String name;
    private Integer age;
    private Integer height;
}
public class Demo03Lambda {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add(new Person("zans",12,156));
        list.add(new Person("lis",13,170));
        list.add(new Person("ww",21,168));
        list.add(new Person("zl",32,163));
//        Collections.sort(list, new Comparator() {
//            @Override
//            public int compare(Person o1, Person o2) {
//                return o1.getAge()-o2.getAge();
//            }
//        });
        Collections.sort(list,((o1, o2) -> {
            return o1.getAge()-o2.getAge();
        }));
        for (Person person : list) {
            System.out.println(person);
        }
    }
}

在lambda表达式的标准写法基础上，可以使用省略写法的规则为:

  • 小括号内的参数类型可以省略；
  • 如果小括号内有且仅有一个参数，则小括号可以省略；
  • 如果大括号内有且仅有一个语句，可以同时省略大括号，return关键字及语句分号。

 例如下面例子：

public interface OrderService {
    String show(String name);
}
public interface StudentService {
    String show(String name,Integer age);
}
public class Demo04Lambda {
    public static void main(String[] args) {
        goStudent((String name,Integer age)->{
           return name+age+"666";
        });
        //省略写法
        goStudent((name,age)->name+age+"123");

        goOrder((String name)->{
            return name+"333";
        });
        //省略写法
        goOrder(name->name+"123");
    }
    public static void goStudent(StudentService studentService){
        studentService.show("sja",22);
    }
    public static void goOrder(OrderService orderService){
        orderService.show("lili");
    }
}

Lambda表达式的使用前提

Lambda表达式的语法是非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件要特别注意：

1.方法的参数或局部变量类型必须为接口才能使用Lambda

2.接口中有且仅有一个抽象方法(@Functionallnterface)

//@FunctionalInterface:被该注解修饰的接口只能有一个抽象方法
@FunctionalInterface
public interface UserService {
    void show();
}

Lambda和匿名内部类的对比

1.所需类型不—样

  • 匿名内部类的类型可以是类，抽象类，接口Lambda表达式需要的类型必须是接口

2.抽象方法的数量不—样

  • 匿名内部类所需的接口中的抽象方法的数量是随意的，Lambda表达式所需的接口中只能有一个抽象方法

3.实现原理不—样

  • 匿名内部类是在编译后形成—个class
  • Lambda表达式是在程序运行的时候动忝生成class

函数式接口

如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。

我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。

Lambda表达式的本质：作为函数式接口的实例

Java8中关于Lambda表达式提供的4个基本的函数式接口（作用：在写lambda表达式的时候没有必要自己声明接口）：

Consumer

Consumer（有参无返回值的接口），对于lambda表达式需要提供一个返回数据的类型，是用来消

费数据的，使用时需要指定一个泛型来定义参数类型。源码如下：

@FunctionalInterface
public interface Consumer {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);
    
    default Consumer andThen(Consumer after) {
    Objects.requireNonNull(after);
    return (T t) -> { accept(t); after.accept(t); };
}

使用：

public class ConsumerText {
    public static void main(String[] args) {
        test(msg->{
            System.out.println(msg+"->转换为小写"+msg.toLowerCase());
        });
    }
    public static void test(Consumer consumer){
        consumer.accept("Hello Word");
    }
}

默认方法:andThen

如果一个方法的参数和返回值全部是Consumer类型，那么就可以实现效果，消费一个数据的时

候，首先做一个操作，然后再做一个操作，实现组合，而这个方法就是Consumer接口中的default

方法andThen方法。

public class ConsumerText {
    public static void main(String[] args) {
        test(msg1->{
            System.out.println(msg1+"->转换为小写"+msg1.toLowerCase());
        },msg2->{
            System.out.println(msg2+"->转换为小写"+msg2.toUpperCase());
        });
    }
    public static void test(Consumer c1,Consumer c2){
       String str = "Hello Word";
//        c1.accept("Hello Word");
//        c2.accept("Hello Word");
        c1.andThen(c2).accept(str);
        c2.andThen(c1).accept(str);
    }
}

Function

Function（有参有返回值接口），Function接口是根据一个类型的数据得到另一个类型的数据，前

者称为前置条件，后者称为后置条件。源码如下：

public interface Function {
    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);

使用：传递一个字符串，返回一个数字

public class FunctionTest {
    public static void main(String[] args) {
        test(msg->{
            return Integer.parseInt(msg);
        });
    }
    public static void test(Function function){
        Integer apply = function.apply("666");
        System.out.println("apply="+apply);

    }
}

默认方法：andThen，也是用来进行组合操作，compose就是andthen反过来的效果,而静态方法

identity则是输入什么参数就返回什么参数 。

public class FunctionTest {
    public static void main(String[] args) {
        test(msg->{
            return Integer.parseInt(msg);
        },msg2->{
            return msg2 * 10;
        });
    }
    public static void test(Function function1,Function function2){
        Integer i2 = function1.andThen(function2).apply("88");
        Integer i2 = function2.compose(function1).apply("88");
        System.out.println("i2"+i2);
    }
}

Supplier

Supplier（无参有返回值类型，是用来生产数据的）

@FunctionalInterface
public interface Supplier {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

使用：

import java.util.Arrays;
import java.util.function.Supplier;
public class SupplierTest {
    public static void main(String[] args) {
        fun1(()->{
            int arr[]={22,11,56,42,99,8};
            //计算出数组中的最大值
            Arrays.sort(arr);
            return arr[arr.length-1];
        });
    }
    private static void fun1(Supplier supplier){
        Integer max = supplier.get();
        System.out.println("max="+max);
    }
}

Predicate

Predicate（有参，返回值为Boolean型接口）

@FunctionalInterface
public interface Predicate {
    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);
    default Predicate and(Predicate other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) && other.test(t);
    default Predicate negate() {
        return (t) -> !test(t);
    }
    default Predicate or(Predicate other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }
    static  Predicate isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

使用：如果msg长度大于3，返回true

public class predicateTest {
    public static void main(String[] args) {
        test(msg->{
            return msg.length()>3;
        },"hahahha");
    }
    public static void test(Predicate predicate,String msg){
        boolean b = predicate.test(msg);
        System.out.println("b"+b);
    }
}

 在Predicate中的默认方法提供了逻辑关系操作 and or negate isEquals方法

public class predicateTest {
    public static void main(String[] args) {
        test(msg1->{
            return msg1.contains("H");
        },msg2->{
            return msg2.contains("W");
        });
    }
    public static void test(Predicate p1,Predicate p2){
       //P1包含H，同时p2包含w
        boolean pp1 = p1.and(p2).test("Hello");
        //P1包含H，或者p2包含w
        boolean pp2 = p1.or(p2).test("Hello");
        //p1不包含H
        boolean pp3 = p1.negate().test("Hello");
    }
}

方法引用

在Lambda表达式中要执行的代码和我们另一个方法中的代码是一样的，这时就没有必要重写一份

逻辑了，这时我们就可以“引用”重复代码。

public class FunctionRefTest02 {
    public static void main(String[] args) {
        printMax(FunctionRefTest02::getTotal);
    }
    public static void getTotal(int a[]){
        int sum=0;
        for (int i : a) {
            sum+=i;
        }
        System.out.println("数组织和："+sum);
    }
    private static void printMax(Consumer consumer){
        int[] a = {10,20,30,40,50};
        consumer.accept(a);
    }
}

符号表示 ::

应用场景：如果Lambda表达式所要实现的方案，已经有其他方法存在相同的方案，那么则可以使用方法引用。

常见的引用方式：

方法引用在JDK8中使用是相当灵活的，有以下几种形式：

1. instanceName::methodName 对象::方法名

2. ClassName::staticMethodName 类名::静态方法

3. ClassName::methodName 类名::普通方法

4. ClassName::new 类名::new 调用的构造器

5. TypeName[]::new String[]::new 调用数组的构造器

方法引用的注意事项：

1. 被引用的方法，参数要和接口中的抽象方法的参数一样

2. 当接口抽象方法有返回值时，被引用的方法也必须有返回值

对象::方法名

这是最常见的一种用法。如果一个类中已经存在了一个成员方法，则可以通过对象名引用成员方法

public class FunctionRefTest3 {
    public static void main(String[] args) {
        Date now = new Date();
        Supplier supplier = ()->{return now.getTime();};
        System.out.println(supplier.get());
        //通过方法引用
        Supplier supplier1 =now::getTime;
        System.out.println(supplier1.get());
    }
}

 类名::静态方法名

public class FunctionRefTest4 {
    public static void main(String[] args) {
        Supplier supplier1 = ()->{
            return System.currentTimeMillis();
        };
        System.out.println(supplier1.get());
        //通过方法引用
        Supplier supplier2 = System::currentTimeMillis;
        System.out.println(supplier2.get());
    }
}

类名::引用实例方法

Java面向对象中，类名只能调用静态方法，类名引用实例方法是有前提的，实际上是拿第一个参数

作为方法的调用者。

public class FunctionRefTest5 {
    public static void main(String[] args) {
        Function function=(s)->{
            return s.length();
        };
        System.out.println(function.apply("hello"));
        //通过方法引用实现
        Function function2=String::length;
        System.out.println(function2.apply("hahahha"));
        BiFunction function3 = String::substring;
        System.out.println(function3.apply("hhhhhhhh", 3));
    }
}

类名::构造器

由于构造器的名称和类名完全一致，所以构造器引用使用 ::new 的格式使用

public class FunctionRefTest6 {
    public static void main(String[] args) {
        Supplier person1 = () -> {
            return new Person();
        };
        System.out.println(person1.get());
        //方法引用
        Supplier person2 = Person::new;
        System.out.println(person2.get());
        BiFunction function = Person::new;
        System.out.println(function.apply("zs", 22));
    }
}

数组::构造器 

public class FunctionRefTest7 {
    public static void main(String[] args) {
        Function fun = (len)->{
            return new String[len];
        };
        String[] strings = fun.apply(3);
        System.out.println("数组的长度："+strings.length);
        //方法引用，调用数组的构造器
        Function fun1 = String[]::new;
        String[] strings1 = fun1.apply(5);
        System.out.println("数组的长度："+strings1.length);
    }
}

Stream API

当我们在需要对集合中的元素进行操作的时候，除了必需的添加，删除，获取外，最典型的操作就

是集合遍历。针对与我们不同的需求总是一次次的循环，这时我们希望有更加高效的处理方式，就

可以通过JDK8中提供的Stream API来解决这个问题。

public class FunctionRefTest8 {
    public static void main(String[] args) {
        //定义一个集合
        List list = Arrays.asList("张三","张三丰","成龙","周星驰");
        // 1.获取所有 姓张的信息
        // 2.获取名称长度为3的用户
        // 3. 输出所有的用户信息
        list.stream().filter(s->s.startsWith("张"))
                .filter(s->s.length()==3)
                .forEach(System.out::println);
    }
}

注意：Stream和IO流(InputStream/OutputStream)没有任何关系。

Stream流式思想类似于工厂车间的“生产流水线”，Stream流不是一种数据结构，不保存数据，而是

对数据进行加工处理。Stream可以看作是流水线上的一个工序。在流水线上，通过多个工序让一

个原材料加工成一个商品。

Stream流的获取方式

根据conllection获取

首先，java.util.Collection 接口中加入了default方法 stream，也就是说Collection接口下的所有的实

现都可以通过steam方法来获取Stream流。

public class streamTest1 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.stream();
        HashSet set = new HashSet<>();
        set.stream();
        Vector vector = new Vector<>();
        vector.stream();
    }
}
 
  
但是Map接口别没有实现Collection接口，那这时怎么办呢？这时我们可以根据Map获取对应的key
 
  
value的集合。 
 
  
public class streamTest1 {
    public static void main(String[] args) {
        HashMap map = new HashMap<>();
        Stream stream = map.keySet().stream();
        Stream stream1 = map.values().stream();
        Stream> stream2 = map.entrySet().stream();
    }
} 
  
通过stream.of方法获取
 
  
在实际开发中我们不可避免的还是会操作到数组中的数据，由于数组对象不可能添加默认方法，所
 
  
有Stream接口中提供了静态方法of。
 
  
 
 
  
public class streamTest1 {
    public static void main(String[] args) {
        Stream a = Stream.of("a", "b", "c");
        String[] a1 =  {"aa","bb","cc"};
        Stream a11 = Stream.of(a1);
        Integer[] c1 = {1,2,3,4};
        Stream c11 = Stream.of(c1);
        //基本数据类型不能获取stream
        int[] d1 = {1,2,3,4};
        Stream.of(d1).forEach(System.out::println);
    }
}
 
  
Stream 常用方法介绍
 
  
java8新特性_第1张图片
 
  
终结方法：返回值类型不再是 Stream 类型的方法，不再支持链式调用。本小节中，终结方法包括 count 和forEach 方法。
 
  
非终结方法：返回值类型仍然是 Stream 类型的方法，支持链式调用（除了终结方法外，其余方法均为非终结方法）。
 
  
Stream注意事项(重要)：
 
  
     
   
  •  Stream只能操作一次
    •  
   
  •  Stream方法返回的是新的流
    •  
   
  • Stream不调用终结方法，中间的操作不会执行
    •  
  
 
  
foreach
 
  
forEach用来遍历流中的数据，该方法接收一个Consumer接口，会将一个流元素交给函数处理
 
  
 
   
 void forEach(Consumer action);
 
  
 
  
public class streamTest1 {
    public static void main(String[] args) {
        Stream.of("a","s","d","f").forEach(System.out::println);
    }
}
 
  
count
 
  
tream流中的count方法用来统计其中的元素个数
 
  
 
   
long count();
 
  
 
  
public class streamTest1 {
    public static void main(String[] args) {
        long count = Stream.of("a", "s", "d", "f").count();
        System.out.println(count);
    }
}
 
  
filter
 
  
filter方法的作用是用来过滤数据的。返回符合条件的数据
 
  
 
   
Stream filter(Predicate predicate);
 
  
 
  
public class streamTest1 {
    public static void main(String[] args) {
        Stream.of("ab","scd" ,"sz2", "ded", "f2")
                .filter(s->s.length()>2)
                .filter(s->s.startsWith("s"))
                .filter(s->s.contains("z")).forEach(System.out::println);
    }
}
 
  
 limit
 
  
 
   
Stream limit(long maxSize);
 
  
 
  
public static void main(String[] args) {
         Stream.of("a1", "a2", "a3","bb","cc","aa","dd")
                 .limit(3)
                 .forEach(System.out::println);
   }
 
  
skip
 
  
如果希望跳过前面几个元素，可以使用skip方法获取一个截取之后的新流：
 
  
 
   
Stream skip(long n);
 
  
 
  
public static void main(String[] args) {
         Stream.of("a1", "a2", "a3","bb","cc","aa","dd")
                 .skip(3)
                 .forEach(System.out::println);
   }
 
  
map
 
  
如果我们需要将流中的元素映射到另一个流中，可以使用map方法：
 
  
 
   
Stream map(Function super T, ? extends R> mapper); 
 
  
 
  
public class streamTest1 {
    public static void main(String[] args) {
        Stream.of("1","2","3","4","5")
//              .map(msg->Integer.parseInt(msg))
                .map(Integer::parseInt)
                .forEach(System.out::println);
    }
}
 
  
sorted
 
  
 
   
Stream sorted();
 
  
 
  
public class streamTest1 {
    public static void main(String[] args) {
        Stream.of("1","2" ,"3","4","5")
                .map(Integer::parseInt)
//                .sorted()//自然排序
                .sorted((o1,o2)->o2-o1)//根据比较器指定排序规则（倒序）
                .forEach(System.out::println);
    }
}
 
  
distinct
 
  
 
   
Stream distinct();
 
  
 
  
public class streamTest1 {
    public static void main(String[] args) {
        Stream.of("1","2" ,"2","4","1")
               .distinct()
                .forEach(System.out::println);
        Stream.of(
                new Person("zs",21)
                ,new Person("lis",21)
                ,new Person("zs",21)
        ).distinct().forEach(System.out::println);
    }
}
 
  
Stream流中的distinct方法对于基本数据类型是可以直接去重的，但是对于自定义类型，我们是需
 
  
要重写hashCode和equals方法来移除重复元素。
 
  
match
 
  
如果需要判断数据是否匹配指定的条件，可以使用match相关的方法
 
  
 
   
boolean anyMatch(Predicate super T> predicate); // 元素是否有任意一个满足条件
 
   
boolean allMatch(Predicate super T> predicate); // 元素是否都满足条件
 
   
boolean noneMatch(Predicate super T> predicate); // 元素是否都不满足条件
 
  
 
  
public class streamTest1 {
    public static void main(String[] args) {
        boolean b = Stream.of("1", "4", "5", "3", "6")
                .map(Integer::parseInt)
//                .anyMatch(s->s>3)
//                .allMatch(s->s>0)
                .noneMatch(s -> s > 7);
        System.out.println(b);
    }
}
 
  
find
 
  
 
   
Optional findFirst();
 
   
Optional findAny();
 
  
 
  
public class streamTest1 {
    public static void main(String[] args) {
        Optional first = Stream.of("1", "4", "5", "3", "6")
                .findFirst();
        System.out.println(first.get());
        Optional any = Stream.of("1", "4", "5", "3", "6").findAny();
        System.out.println(any.get());
    }
}
 
  
max和min
 
  
 
   
Optional min(Comparator super T> comparator);
 
   
Optional max(Comparator super T> comparator);
 
  
 
  
public class streamTest1 {
    public static void main(String[] args) {
        Optional max = Stream.of("1", "4", "5", "3", "6")
                .map(Integer::parseInt)
                .max((o1, o2) -> o1 - o2);
        System.out.println(max.get());
        Optional min = Stream.of("1", "4", "5", "3", "6")
                .map(Integer::parseInt).min((o1, o2) -> o1 - o2);
        System.out.println(min.get());
    }
}
 
  
reduce
 
  
归并计算，为终端操作，可以对中间操作筛选出来的流数据作出一系列的加减乘除等操作。
 
  
 
   
T reduce(T identity, BinaryOperator accumulator); 
 
  
 
  
public class streamTest1 {
    public static void main(String[] args) {
        Integer reduce = Stream.of("1", "4", "5", "3", "6")
                .map(Integer::parseInt)
                .reduce(0, Integer::sum);
        System.out.println(reduce);
        Integer reduce1 = Stream.of("1", "4", "5", "3", "6")
                .map(Integer::parseInt)
                .reduce(0, (x, y) -> x > y ? x : y);
        System.out.println(reduce1);
    }
}
 
  
reduce和map组合 
 
  
public class streamTest1 {
    public static void main(String[] args) {
        // 1.求出所有年龄的总和
        Optional reduce = Stream.of(
                new Person("zs", 12)
                , new Person("zs", 23)
                , new Person("zs", 25)
        ).map(Person::getAge).reduce(Integer::sum);
        System.out.println(reduce.get());
        // 1.求出所有年龄的最大值
        Optional reduce1 = Stream.of(
                new Person("zs", 12)
                , new Person("zs", 23)
                , new Person("zs", 25)
        ).map(Person::getAge).reduce(Math::max);
        System.out.println(reduce1.get());
        //统计字符a出现的次数
        Integer total = Stream.of("a", "a", "a", "b", "b", "c").map(s -> "a".equals(s) ? 1 : 0).reduce(0, Integer::sum);
        System.out.println(total);
    }
}
 
  
concat 
 
  
public class streamTest1 {
    public static void main(String[] args) {
        Stream stream1 = Stream.of("1", "2", "3");
        Stream stream2 = Stream.of("4", "5", "6");
        Stream.concat(stream1,stream2).forEach(System.out::println);
    }
}
 
  
mapToInt
 
  
如果需要将Stream中的Integer类型转换成int类型，可以使用mapToInt方法来实现
 
  
public class streamTest1 {
    public static void main(String[] args) {
      Integer arr[] = {1,2,3,4,5};
        IntStream toInt = Stream.of(arr).mapToInt(Integer::intValue);
        System.out.println(toInt);
    }
}
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • JavaScript `Map` 和 `WeakMap`详细解释
                        跳房子的前端
JavaScript原生方法javascript前端开发语言
                        
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
    
                    
    • 
                    
  • 切换淘宝最新npm镜像源是
                        hai40587
npm前端node.js
                        
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
    
                    
    • 
                    
  • 【Java】已解决：java.util.concurrent.CompletionException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
    
                    
    • 
                    
  • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】）
                        ok!ko
设计模式设计模式建造者模式java
                        
    文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
    
                    
    • 
                                
  • tomcat基础与部署发布
                                    暗黑小菠萝
Tomcat java web
                                    
    从51cto搬家了，以后会更新在这里方便自己查看。 
做项目一直用tomcat，都是配置到eclipse中使用，这几天有时间整理一下使用心得，有一些自己配置遇到的细节问题。 
Tomcat：一个Servlets和JSP页面的容器，以提供网站服务。 
一、Tomcat安装 
    安装方式：①运行.exe安装包 
     &n
    
                                
    • 
                                
  • 网站架构发展的过程
                                    ayaoxinchao
数据库应用服务器网站架构
                                    
    1.初始阶段网站架构：应用程序、数据库、文件等资源在同一个服务器上 
2.应用服务和数据服务分离：应用服务器、数据库服务器、文件服务器 
3.使用缓存改善网站性能：为应用服务器提供本地缓存，但受限于应用服务器的内存容量，可以使用专门的缓存服务器，提供分布式缓存服务器架构 
4.使用应用服务器集群改善网站的并发处理能力：使用负载均衡调度服务器，将来自客户端浏览器的访问请求分发到应用服务器集群中的任何
    
                                
    • 
                                
  • [信息与安全]数据库的备份问题
                                    comsci
数据库
                                    
     
 
      如果你们建设的信息系统是采用中心-分支的模式,那么这里有一个问题 
  
 如果你的数据来自中心数据库,那么中心数据库如果出现故障,你的分支机构的数据如何保证安全呢? 
 
   是否应该在这种信息系统结构的基础上进行改造,容许分支机构的信息系统也备份一个中心数据库的文件呢? 
 
 &n
    
                                
    • 
                                
  • 使用maven tomcat plugin插件debug关联源代码
                                    商人shang
mavendebug查看源码tomcat-plugin
                                    
    *首先需要配置好'''maven-tomcat7-plugin'''，参见[[Maven开发Web项目]]的'''Tomcat'''部分。 
*配置好后，在[[Eclipse]]中打开'''Debug Configurations'''界面，在'''Maven Build'''项下新建当前工程的调试。在'''Main'''选项卡中点击'''Browse Workspace...'''选择需要开发的
    
                                
    • 
                                
  • 大访问量高并发
                                    oloz
大访问量高并发
                                    
    大访问量高并发的网站主要压力还是在于数据库的操作上，尽量避免频繁的请求数据库。下面简 
 
要列出几点解决方案： 
 
01、优化你的代码和查询语句，合理使用索引 
 
02、使用缓存技术例如memcache、ecache将不经常变化的数据放入缓存之中 
 
03、采用服务器集群、负载均衡分担大访问量高并发压力 
 
04、数据读写分离 
 
05、合理选用框架，合理架构(推荐分布式架构)。 
 
    
                                
    • 
                                
  • cache 服务器
                                    小猪猪08
cache
                                    
    Cache   即高速缓存.那么cache是怎么样提高系统性能与运行速度呢？是不是在任何情况下用cache都能提高性能？是不是cache用的越多就越好呢？我在近期开发的项目中有所体会，写下来当作总结也希望能跟大家一起探讨探讨，有错误的地方希望大家批评指正。 
　　1.Cache   是怎么样工作的? 
　　Cache   是分配在服务器上
    
                                
    • 
                                
  • mysql存储过程
                                    香水浓
mysql
                                    
    Description:插入大量测试数据 
 
use xmpl;

drop procedure if exists mockup_test_data_sp;

create procedure mockup_test_data_sp(
	in number_of_records int
)
begin
	declare cnt int;
	declare name varch
    
                                
    • 
                                
  • CSS的class、id、css文件名的常用命名规则
                                    agevs
JavaScriptUI框架Ajaxcss
                                    
      CSS的class、id、css文件名的常用命名规则 
    (一)常用的CSS命名规则 
　　头：header 
　　内容：content/container 
　　尾：footer 
　　导航：nav 
　　侧栏：sidebar 
　　栏目：column 
　　页面外围控制整体布局宽度：wrapper 
　　左右中：left right 
    
                                
    • 
                                
  • 全局数据源
                                    AILIKES
javatomcatmysqljdbcJNDI
                                    
    实验目的：为了研究两个项目同时访问一个全局数据源的时候是创建了一个数据源对象，还是创建了两个数据源对象。 
1：将diuid和mysql驱动包（druid-1.0.2.jar和mysql-connector-java-5.1.15.jar）copy至%TOMCAT_HOME%/lib下；2：配置数据源，将JNDI在%TOMCAT_HOME%/conf/context.xml中配置好,格式如下：&l
    
                                
    • 
                                
  • MYSQL的随机查询的实现方法
                                    baalwolf
mysql
                                    
    MYSQL的随机抽取实现方法。举个例子，要从tablename表中随机提取一条记录，大家一般的写法就是：SELECT * FROM tablename ORDER BY RAND() LIMIT 1。但是，后来我查了一下MYSQL的官方手册，里面针对RAND()的提示大概意思就是，在ORDER BY从句里面不能使用RAND()函数，因为这样会导致数据列被多次扫描。但是在MYSQL 3.23版本中，
    
                                
    • 
                                
  • JAVA的getBytes()方法
                                    bijian1013
javaeclipseunixOS
                                    
        在Java中，String的getBytes()方法是得到一个操作系统默认的编码格式的字节数组。这个表示在不同OS下，返回的东西不一样！  
    String.getBytes(String decode)方法会根据指定的decode编码返回某字符串在该编码下的byte数组表示，如： 
    byte[] b_gbk = "
    
                                
    • 
                                
  • AngularJS中操作Cookies
                                    bijian1013
JavaScriptAngularJSCookies
                                    
            如果你的应用足够大、足够复杂，那么你很快就会遇到这样一咱种情况：你需要在客户端存储一些状态信息，这些状态信息是跨session(会话)的。你可能还记得利用document.cookie接口直接操作纯文本cookie的痛苦经历。 
        幸运的是，这种方式已经一去不复返了，在所有现代浏览器中几乎
    
                                
    • 
                                
  • [Maven学习笔记五]Maven聚合和继承特性
                                    bit1129
maven
                                    
    Maven聚合 
  
在实际的项目中，一个项目通常会划分为多个模块，为了说明问题，以用户登陆这个小web应用为例。通常一个web应用分为三个模块：   
1. 模型和数据持久化层user-core, 
2. 业务逻辑层user-service以 
3. web展现层user-web， 
user-service依赖于user-core 
user-web依赖于user-core和use
    
                                
    • 
                                
  • 【JVM七】JVM知识点总结
                                    bit1129
jvm
                                    
      1. JVM运行模式 
1.1 JVM运行时分为-server和-client两种模式，在32位机器上只有client模式的JVM。通常，64位的JVM默认都是使用server模式，因为server模式的JVM虽然启动慢点，但是，在运行过程，JVM会尽可能的进行优化 
1.2 JVM分为三种字节码解释执行方式：mixed mode, interpret mode以及compiler 
    
                                
    • 
                                
  • linux下查看nginx、apache、mysql、php的编译参数
                                    ronin47

                                    
    在linux平台下的应用，最流行的莫过于nginx、apache、mysql、php几个。而这几个常用的应用，在手工编译完以后，在其他一些情况下（如：新增模块），往往想要查看当初都使用了那些参数进行的编译。这时候就可以利用以下方法查看。 
1、nginx 
[root@361way ~]# /App/nginx/sbin/nginx -V
nginx: nginx version: nginx/
    
                                
    • 
                                
  • unity中运用Resources.Load的方法？
                                    brotherlamp
unity视频unity资料unity自学unityunity教程
                                    
    问：unity中运用Resources.Load的方法？ 
答：Resources.Load是unity本地动态加载资本所用的方法,也即是你想动态加载的时分才用到它,比方枪弹,特效,某些实时替换的图像什么的,主张此文件夹不要放太多东西,在打包的时分,它会独自把里边的一切东西都会集打包到一同,不论里边有没有你用的东西,所以大多数资本应该是自个建文件放置 
1、unity实时替换的物体即是依据环境条件
    
                                
    • 
                                
  • 线段树-入门
                                    bylijinnan
java算法线段树
                                    
    


/**
 * 线段树入门
 * 问题：已知线段[2,5] [4,6] [0,7]；求点2,4,7分别出现了多少次
 * 以下代码建立的线段树用链表来保存，且树的叶子结点类似[i,i]
 * 
 * 参考链接：http://hi.baidu.com/semluhiigubbqvq/item/be736a33a8864789f4e4ad18
 * @author lijinna
    
                                
    • 
                                
  • 全选与反选
                                    chicony
全选
                                    
      
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>全选与反选</title>

    
                                
    • 
                                
  • vim一些简单记录
                                    chenchao051
vim
                                    
    mac在/usr/share/vim/vimrc linux在/etc/vimrc 
  
1、问：后退键不能删除数据，不能往后退怎么办？ 
      答：在vimrc中加入set backspace=2 
  
2、问：如何控制tab键的缩进？ 
      答：在vimrc中加入set tabstop=4 (任何
    
                                
    • 
                                
  • Sublime Text 快捷键
                                    daizj
快捷键sublime
                                    
    [size=large][/size]Sublime Text快捷键：Ctrl+Shift+P：打开命令面板Ctrl+P：搜索项目中的文件Ctrl+G：跳转到第几行Ctrl+W：关闭当前打开文件Ctrl+Shift+W：关闭所有打开文件Ctrl+Shift+V：粘贴并格式化Ctrl+D：选择单词，重复可增加选择下一个相同的单词Ctrl+L：选择行，重复可依次增加选择下一行Ctrl+Shift+L：
    
                                
    • 
                                
  • php 引用(&)详解
                                    dcj3sjt126com
PHP
                                    
    在PHP 中引用的意思是：不同的名字访问同一个变量内容. 与Ｃ语言中的指针是有差别的．Ｃ语言中的指针里面存储的是变量的内容在内存中存放的地址 变量的引用 PHP 的引用允许你用两个变量来指向同一个内容   复制代码代码如下:   
<?  
$a="ABC";  
$b =&$a;  
echo
    
                                
    • 
                                
  • SVN中trunk,branches,tags用法详解
                                    dcj3sjt126com
SVN
                                    
    Subversion有一个很标准的目录结构，是这样的。比如项目是proj，svn地址为svn://proj/，那么标准的svn布局是svn://proj/|+-trunk+-branches+-tags这是一个标准的布局，trunk为主开发目录，branches为分支开发目录，tags为tag存档目录（不允许修改）。但是具体这几个目录应该如何使用，svn并没有明确的规范，更多的还是用户自己的习惯。
    
                                
    • 
                                
  • 对软件设计的思考
                                    e200702084
设计模式数据结构算法ssh活动
                                    
    软件设计的宏观与微观  
 
   软件开发是一种高智商的开发活动。一个优秀的软件设计人员不仅要从宏观上把握软件之间的开发，也要从微观上把握软件之间的开发。宏观上，可以应用面向对象设计，采用流行的SSH架构，采用web层，业务逻辑层，持久层分层架构。采用设计模式提供系统的健壮性和可维护性。微观上，对于一个类，甚至方法的调用，从计算机的角度模拟程序的运行情况。了解内存分配，参数传
    
                                
    • 
                                
  • 同步、异步、阻塞、非阻塞
                                    geeksun
非阻塞
                                    
    同步、异步、阻塞、非阻塞这几个概念有时有点混淆，在此文试图解释一下。 
  
同步：发出方法调用后，当没有返回结果，当前线程会一直在等待（阻塞）状态。 
场景：打电话，营业厅窗口办业务、B/S架构的http请求-响应模式。 
  
异步：方法调用后不立即返回结果，调用结果通过状态、通知或回调通知方法调用者或接收者。异步方法调用后，当前线程不会阻塞，会继续执行其他任务。 
实现：
    
                                
    • 
                                
  • Reverse SSH Tunnel 反向打洞實錄
                                    hongtoushizi
ssh
                                    
    實際的操作步驟：  
# 首先，在客戶那理的機器下指令連回我們自己的 Server，並設定自己 Server 上的 12345 port 會對應到幾器上的 SSH port
ssh -NfR 12345:localhost:22 [email protected]

# 然後在 myhost 的機器上連自己的 12345 port，就可以連回在客戶那的機器
ssh localhost -p 1
    
                                
    • 
                                
  • Hibernate中的缓存
                                    Josh_Persistence
一级缓存Hiberante缓存查询缓存二级缓存
                                    
    Hibernate中的缓存 
  
一、Hiberante中常见的三大缓存：一级缓存，二级缓存和查询缓存。 
Hibernate中提供了两级Cache，第一级别的缓存是Session级别的缓存，它是属于事务范围的缓存。这一级别的缓存是由hibernate管理的，一般情况下无需进行干预；第二级别的缓存是SessionFactory级别的缓存，它是属于进程范围或群集范围的缓存。这一级别的缓存
    
                                
    • 
                                
  • 对象关系行为模式之延迟加载
                                    home198979
PHP架构延迟加载
                                    
    形象化设计模式实战     HELLO!架构 
  
一、概念 
Lazy Load：一个对象，它虽然不包含所需要的所有数据，但是知道怎么获取这些数据。 
延迟加载貌似很简单，就是在数据需要时再从数据库获取，减少数据库的消耗。但这其中还是有不少技巧的。 
  
  
二、实现延迟加载 
实现Lazy Load主要有四种方法：延迟初始化、虚
    
                                
    • 
                                
  • xml 验证
                                    pengfeicao521
xmlxml解析
                                    
    有些字符，xml不能识别，用jdom或者dom4j解析的时候就报错 
 
public static void testPattern() { 
 
 // 含有非法字符的串 
 String str =       "Jamey&#52828;&#01;&#02;&#209;&#1282
    
                                
    • 
                                
  • div设置半透明效果
                                    spjich
css半透明
                                    
    为div设置如下样式： 
  
div{filter:alpha(Opacity=80);-moz-opacity:0.5;opacity: 0.5;}  
  
  
  
 说明： 
1、filter：对win IE设置半透明滤镜效果，filter:alpha(Opacity=80)代表该对象80%半透明，火狐浏览器不认2、-moz-opaci
    
                                
    • 
                                
  • 你真的了解单例模式么？
                                    w574240966
java单例设计模式jvm
                                    
        单例模式，很多初学者认为单例模式很简单，并且认为自己已经掌握了这种设计模式。但事实上，你真的了解单例模式了么。 
  
一，单例模式的5中写法。（回字的四种写法，哈哈。） 
    1，懒汉式 
          （1）线程不安全的懒汉式 
    public cla
    
                                
    •