这是真的。
这个村庄的小康之家的女孩子，生的美，有许多人来做媒，但都没有说成。那你她不过十五六岁吧，是春天的晚上，她立在门后，手扶着桃树。她记得她穿着一件月白色的衫子，对门住的年轻人，同她见过面，可是从来没有打过招呼的。他走了过来，离的不远，站定了，轻轻说了一声：“噢，你也在这里吗。”她没有说什么，他也没有再说什么，站了一会，各自走开了。
就这样就完了。
后来这女人被亲眷拐了，卖到他乡外县去作妾，又几次三番被转卖，经过无数的惊险的风波，老了的时候她还记得从前的那一回事，常常说起，在那春天的晚上，在后门口的桃树下，那年轻人。
于千万人之中遇到你所要遇到的人，于千万年之中，时间的无涯的荒野中，没有早一步，也没有晚一步，刚巧赶上了，那也没有别的话好说，唯有轻轻的问一声：“噢，你也在这里吗？”
Runtime.getRuntime().available-Processors() // show initial number of thread System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism","12"); // change the number of initial thread
public static long parallelSum(long n) { return Stream.iterate(1L, i -> i + 1).limit(n).parallel().reduce(0L, Long::sum); }
long start = System.nanoTime(); // apply batch calculation here long duration = (System.nanoTime() - start) / 1_000_000;
public static long parallelRangedSum(long n) { return LongStream.rangeClosed(1, n).parallel().reduce(0L, Long::sum); }
public class ForkJoinSumCalculator extends RecursiveTask<Long> {
// constructors and fields ....
@Override
protected Long compute() { // rewrite abstract method
if (length <= 1000) {
// Don't use parallel
}
ForkJoinSumCalculator leftTask = new ForkJoinSumCalculator(20000, 1, 10000);
leftTask.fork(); // start left half tasks asyncronously in another ForkJoinPool
ForkJoinSumCalculator rightTask = new ForkJoinSumCalculator(20000, 10001, 20000);
Long rightResult = rightTask.compute(); // start the right half tasks
Long leftResult = leftTask.join(); // read the left half tasks result. blocking
return leftResult + rightResult; // combine
}
}
public interface Spliterator<T> { boolean tryAdvance(Consumer<? super T> action); // iterate all elements Consumer provides Spliterator<T> trySplit(); // split data into another Spliterator long estimateSize(); // return the size of collection int characteristics(); }
long howManyDishes = menu.stream().collect(Collectors.counting()); // == long howManyDishes2 = menu.stream().count(); Comparator<Dish> dishCaloriesComparator = Comparator.comparingInt(Dish::getCalories); Optional<Dish> mostCalorieDish = menu.stream() .collect(Collectors.maxBy(dishCaloriesComparator)); // get object with max calories // get the total calories int totalCalories = menu.stream().collect(Collectors.summingInt(Dish::getCalories)); // get the average calories double avgCalories = menu.stream().collect(Collectors.averagingInt(Dish::getCalories)); // get total, average, max, min IntSummaryStatistics menuStatistics = menu.stream().collect(
Collectors.summarizingInt(Dish::getCalories));
String shortMenu = menu.stream().map(Dish::getName).collect(Collectors.joining(", "));
// get total calories in reduing way int totalCalories2 = menu.stream().collect(Collectors.reducing(0, Dish::getCalories,
(i, j) -> i + j)); // get the max calories Optional<Dish> mostCalorieDish2 = menu.stream().collect(Collectors.reducing( (d1, d2) -> d1.getCalories() > d2.getCalories() ? d1 : d2)); // self-implement toList collector Stream<Integer> stream = Arrays.asList(1, 2, 3, 4, 5, 6).stream(); List<Integer> numbers = stream.reduce(new ArrayList<Integer>(), // init value (List<Integer> l, Integer e) -> { l.add(e);return l; }, // process (List<Integer> l1, List<Integer> l2) -> {
l1.addAll(l2);return l1; }); // final process // total calories int totalCalories3 = menu.stream().collect(Collectors.reducing(0,Dish::getCalories,
Integer::sum)); int totalCalories4 = menu.stream().mapToInt(Dish::getCalories).sum(); // old way
// group by type , type is an enum Map<Dish.Type, List<Dish>> dishesByType = menu.stream().collect(
Collectors.groupingBy(Dish::getType)); // criteria grouping Map<CaloricLevel, List<Dish>> dishesByCaloricLevel = menu.stream().collect( Collectors.groupingBy(dish -> { if (dish.getCalories() <= 400) { return CaloricLevel.DIET; } else if (dish.getCalories() <= 700) { return CaloricLevel.NORMAL; }else { return CaloricLevel.FAT; }})); // nested grouping Map<Dish.Type, Map<CaloricLevel, List<Dish>>> dishesByTypeCaloricLevel =
menu.stream().collect( Collectors.groupingBy(Dish::getType, // 1st grouping Collectors.groupingBy(dish -> { // 2ed grouping if (dish.getCalories() <= 400) return CaloricLevel.DIET; else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL; else return CaloricLevel.FAT; }))); // collecting data with grouping // result is : {MEAT=3, FISH=2, OTHER=4} Map<Dish.Type, Long> typesCount = menu.stream().collect(
Collectors.groupingBy(Dish::getType, Collectors.counting())); // get the max calories of each group , group by type //result is : {FISH=Optional[salmon], OTHER=Optional[pizza], MEAT=Optional[pork]} Map<Dish.Type, Optional<Dish>> mostCaloricByType = menu.stream().collect(
Collectors.groupingBy(Dish::getType, Collectors.maxBy(Comparator.comparingInt(Dish::getCalories)))); // get the max colories of each group , retrive value of each optional from above //result is {FISH=salmon, OTHER=pizza, MEAT=pork} Map<Dish.Type, Dish> mostCaloricByType2 = menu.stream().collect(
Collectors.groupingBy(Dish::getType, // group by type Collectors.collectingAndThen(Collectors.maxBy(
Comparator.comparingInt(Dish::getCalories)), //transformed Collector
Optional::get))); // function of transfering // grouping by can pass in 2 params , the second param will apply to all elements of each group. Map<Dish.Type, Integer> totalCaloriesByType = menu.stream().collect(
Collectors.groupingBy(Dish::getType, Collectors.summingInt(Dish::getCalories))); // get all caloricLevels of each Dish Type // Collectors.mapping is powerful like map() Map<Dish.Type, Set<CaloricLevel>> caloricLevelsByType = menu.stream().collect( Collectors.groupingBy(Dish::getType, Collectors.mapping( dish -> { if (dish.getCalories() <= 400) { return CaloricLevel.DIET; } else if (dish.getCalories() <= 700) { return CaloricLevel.NORMAL; } else { return CaloricLevel.FAT; }},Collectors.toSet()))); // point out which kind of set you want to use Map<Dish.Type, Set<CaloricLevel>> caloricLevelsByType2 = menu.stream().collect( Collectors.groupingBy(Dish::getType, Collectors.mapping( dish -> { if (dish.getCalories() <= 400) { return CaloricLevel.DIET; } else if (dish.getCalories() <= 700) { return CaloricLevel.NORMAL; } else { return CaloricLevel.FAT; }},Collectors.toCollection(HashSet::new))));
//{false=[pork, beef, chicken, prawns, salmon], //true=[french fries, rice, season fruit, pizza]} Map<Boolean, List<Dish>> partitionedMenu = menu.stream().collect(Collectors.partitioningBy(Dish::isVegetarian)); List<Dish> vegetarianDishes = partitionedMenu.get(true); // to retrive values // == List<Dish> vegetarianDishes2 = menu.stream().filter(Dish::isVegetarian).collect(
Collectors.toList()); // nexted partioning & grouping , producing a 2 level grouping //{false={FISH=[prawns, salmon], MEAT=[pork, beef, chicken]}, // true={OTHER=[french fries, rice, season fruit, pizza]}} Map<Boolean, Map<Dish.Type, List<Dish>>> vegetarianDishesByType = menu.stream().collect( Collectors.partitioningBy(Dish::isVegetarian, Collectors.groupingBy(Dish::getType)));
// getType is not predicate so use group by
ByteBuffer.allocateDirect(size)
%%time import numpy as np import pandas as pd from sklearn.lda import LDA from sklearn import datasets from sklearn import metrics from sklearn.model_selection import KFold from sklearn.naive_bayes import GaussianNB # import into bayes lib dataset = pd.read_csv("train.csv") target = dataset[[0]].values.ravel() train = dataset.iloc[:,1:].values test = pd.read_csv("test.csv").values x_finaltest = test # test data kf = KFold(n_splits = 10)
total_score1 = []
gnb = GaussianNB()
for train_index ,test_index in kf.split(train):
x_train = train[train_index]
y_train = target[train_index]
x_test = train[test_index]
y_test = target[test_index]
gnb.fit(x_train, y_train) # train the model
y_predict1 = gnb.predict(x_test) # predict
total_score1.append(metrics.accuracy_score(y_predict1,y_test)) # compare and score
# print average score
print(np.mean(total_score1))
y_pred1 = gnb.predict(x_finaltest) # predict
# save into file
np.savetxt('bayes.csv', np.c_[range(1,len(x_finaltest)+1),y_pred1], delimiter=',',
header = 'ImageId,Label', comments = '', fmt='%d')
0.556166666667 Wall time: 4min 32s
And(&)
|
0 & 0= 0
|
1 & 0 = 0
|
0 & 1= 0
|
1 & 1 =1
|
Or (|)
|
0 | 0 = 0
|
1 | 0 = 1
|
0 | 1 = 1
|
1 | 1 = 1
|
Xor (^)
|
0 | 0 = 0
|
1 | 0 = 1
|
0 | 1 = 1
|
1 | 1 = 0
|
public static int updateBits(int n , int m, int i, int j) { int max = ~0; // All 1's // 1's through position j, then 0's int left = max - ((1 << j) - 1); // 1's after position i int right = ((1 << i) - 1); // 1's , with 0's between i and j int mask = left | right; // clear i through j, then put m in there return (n & mask) | (m << i); }
List<Bid> candidateBid = new ArrayList<>(); PotentialBid potentialBid = new PotentialBid(); candidateBid.stream() .filter(x -> x.getAutionType() == potentialBid.getAutionType()) // int .filter(x -> x.getCountryCode() == potentialBid.getCountryCode()); // String
BitSet candidateBid = new BitSet(); // imagine it has datascandidateBid.and(autionTypeMatch.getCandidates(bid)); // get intersection set == filtercandidateBid.and(countryMatcher.getCandidates(bid)); // get intersection set == filter
public class Car { private String name; // A car must have a name private Optional<Insurance> insurance; // A can can have insurance or not insured }
Optional<Car> optCar = Optional.empty(); // a empty Optional Optional<Car> optCar2 = Optional.of(car); // create an optional from another object Optional<Car> optCar3 = Optional.ofNullable(car); // A optional can accept null. Optional<Insurance> optInsurance = Optional.ofNullable(insurance); Optional<String> name = optInsurance.map(Insurance::getName); // retrive value from Optional Object
// combine multiple filter to retrive public String getCarInsuranceName(Optional<Person> person) { return person.flatMap(Person::getCar) .flatMap(Car::getInsurance) .map(Insurance::getName) .orElse("Unknown"); }
// 2 optional judgetments public Optional<Insurance> FindCheapInsurance(Optional<Person> person, Optional<Car> car { if (person.isPresent() && car.isPresent()) { return Optional.of(findCheapestInsurance(person.get(), car.get())); } else { return Optional.empty(); } }
Object value = map.get("key");
Optional<Object> value = Optional.ofNullable(map.get("key"));
public static int readDuration(Map<String,String> props, String name) { return Optional.ofNullable(props.get(name)) .flatMap(Car::stringToInt) // convert String into Int .filter(i -> i > 0) // filter those > 0 .orElse(0); // if it throws exception or < 0, then make it == 0 } public static Optional<Integer> stringToInt(String s) { try { return Optional.of(Integer.parseInt(s)); // convert String into Int } catch (NumberFormatException e) { return Optional.empty(); } }
public Future<Double> getPriceAsyncBad(String product) {
// create a cf,which will return the result later
CompletableFuture<Double> futurePrice = new CompletableFuture<>();new Thread( () -> { try { double price = calculatePrice(product); // this function will sleep for 1 second System.out.println("api call has finished"); futurePrice.complete(price); // return the value to cf after a long wait, cf stops } catch (Exception ex) { futurePrice.completeExceptionally(ex); // throw exception, and stop the cf } }).start(); // asynchronous computation return futurePrice; }
//new way ,CompletableFuture factory public Future<Double> getPriceAsyncGood(String product) { return CompletableFuture.supplyAsync(() -> calculatePrice(product)); }
public static void main(String[] args) { Shopp shop = new Shopp("BestShop"); Future<Double> futurePrice = shop.getPriceAsyncGood("my favorite product"); System.out.println("Main Thread continue..."); try { double price = futurePrice.get();
// conjested and waiting for future, like a semophore!! code can't continue System.out.println(price); } catch (Exception e) {} }
List<CompletableFuture<String>> priceFutures = shops.stream() .map(shop -> CompletableFuture.supplyAsync(
() -> String.format("%s price is %.2f", shop.getName(),
shop.getPrice(product)))) .collect(Collectors.toList());
public List<String> findPrices(String product) { List<CompletableFuture<String>> priceFutures = shops.stream()
.map(shop -> CompletableFuture.supplyAsync(() -> shop.getName() + " price is " + shop.getPrice(product))) .collect(Collectors.toList()); return priceFutures.stream() .map(CompletableFuture::join) //wait all processes to finish and get
.collect(toList()); }
// optimised threadpool
// threadpool = the smaller between shop size and 100.
Executors.newFixedThreadPool(Math.min(shopp.size(), 100),
new ThreadFactory() {
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setDaemon(true); // use deamon, it won't hinder the application.
return t;
}
});
CompletableFuture.supplyAsync(() -> shop.getName() + " price is " + shop.getPrice(product), executor);
private final Executor executor = public List<String> findPrices(String product) { List<CompletableFuture<String>> priceFutures = shops.stream()
// asyn to get price
.map(shop -> CompletableFuture.supplyAsync(() -> shop.getPrice(product), executor)) .map(future -> future.thenApply(Quote::parse)) // parse the quote .map(future -> future.thenCompose(quote ->
// first cf's result as second cf's input in thenCompose CompletableFuture.supplyAsync(() -> Discount.applyDiscount(quote), executor)))
// asyn to apply quote .collect(Collectors.toList()); return priceFutures.stream().map(CompletableFuture::join).collect(Collectors.toList()); }
Future<Double> futurePriceInUSD = CompletableFuture.supplyAsync(() -> shop.getPrice(product)) .thenCombine( CompletableFuture.supplyAsync( () -> exchangeService.getRate(Money.EUR, Money.USD)), (price, rate) -> price * rate );
CompletableFuture[] futures = findPricesStream("myPhone") // convert into cf array .map(f -> f.thenAccept(System.out::println)) .toArray(size -> new CompletableFuture[size]);
// all threads of cf have return value . then join and return
CompletableFuture.allOf(futures).join();
// any threads of cf have return value . then join and return CompletableFuture.anyOf(futures).join();
findPricesStream("myPhone").map(f -> f.thenAccept(System.out::println));
when web page is busily loading. normally we need to add a spinner for the user to kill their waiting impatience. Here, 2 steps we need to d...
