Add files using upload-large-folder tool

.gitattributes

@@ -65,3 +65,11 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 07[[:space:]]-[[:space:]]Control[[:space:]]Statements/007[[:space:]]Homework[[:space:]]review[[:space:]]'switch'[[:space:]]statement.mp4 filter=lfs diff=lfs merge=lfs -text
 08[[:space:]]-[[:space:]]Miscellaneous/001[[:space:]]Random[[:space:]]numbers[[:space:]]generation.mp4 filter=lfs diff=lfs merge=lfs -text
 07[[:space:]]-[[:space:]]Control[[:space:]]Statements/005[[:space:]]'switch'[[:space:]]construction.mp4 filter=lfs diff=lfs merge=lfs -text
+09[[:space:]]-[[:space:]]Iteration[[:space:]]Statements[[:space:]](Loops)[[:space:]]in[[:space:]]Java/001[[:space:]]'while'[[:space:]]loop.mp4 filter=lfs diff=lfs merge=lfs -text
+09[[:space:]]-[[:space:]]Iteration[[:space:]]Statements[[:space:]](Loops)[[:space:]]in[[:space:]]Java/002[[:space:]]'do-while'[[:space:]]loop.mp4 filter=lfs diff=lfs merge=lfs -text
+09[[:space:]]-[[:space:]]Iteration[[:space:]]Statements[[:space:]](Loops)[[:space:]]in[[:space:]]Java/004[[:space:]]'for[[:space:]]each'[[:space:]]loop.mp4 filter=lfs diff=lfs merge=lfs -text
+09[[:space:]]-[[:space:]]Iteration[[:space:]]Statements[[:space:]](Loops)[[:space:]]in[[:space:]]Java/003[[:space:]]'for'[[:space:]]with[[:space:]]condition[[:space:]]loop.mp4 filter=lfs diff=lfs merge=lfs -text
+09[[:space:]]-[[:space:]]Iteration[[:space:]]Statements[[:space:]](Loops)[[:space:]]in[[:space:]]Java/005[[:space:]]Nested[[:space:]]loops.mp4 filter=lfs diff=lfs merge=lfs -text
+09[[:space:]]-[[:space:]]Iteration[[:space:]]Statements[[:space:]](Loops)[[:space:]]in[[:space:]]Java/006[[:space:]]Jump[[:space:]]Statements[[:space:]]-[[:space:]]Break[[:space:]]and[[:space:]]Continue.mp4 filter=lfs diff=lfs merge=lfs -text
+09[[:space:]]-[[:space:]]Iteration[[:space:]]Statements[[:space:]](Loops)[[:space:]]in[[:space:]]Java/007[[:space:]]Labels[[:space:]]in[[:space:]]Java.mp4 filter=lfs diff=lfs merge=lfs -text
+09[[:space:]]-[[:space:]]Iteration[[:space:]]Statements[[:space:]](Loops)[[:space:]]in[[:space:]]Java/011[[:space:]]Homework[[:space:]]review[[:space:]]Iteration[[:space:]]Statements[[:space:]](Loops).mp4 filter=lfs diff=lfs merge=lfs -text

09 - Iteration Statements (Loops) in Java/001 'while' loop.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c629d1d6f638fb968214957658e97c6eb23095272a0bbe7087e6c1348b9c13f0
+size 27823271

09 - Iteration Statements (Loops) in Java/002 'do-while' loop.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5eb2e2c5e7fa0f6dd1adca8edbfab3a5e65e319870309f617ff33511a4dca3f3
+size 35783857

09 - Iteration Statements (Loops) in Java/003 'for' with condition loop.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ec119ea6d92fcd2a3e8d78f2f667e382468584679b989705b9634e0732800192
+size 63924486

09 - Iteration Statements (Loops) in Java/004 'for each' loop.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:71190e257dd46f2405ec5bb73456ccb7cb82f788203ef363051da9451bb18b32
+size 37813640

09 - Iteration Statements (Loops) in Java/005 Nested loops.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b67654f3d53938bf16e584d8ceb6b56cb940f55c5d8368de61776bf849b63161
+size 20391609

09 - Iteration Statements (Loops) in Java/006 Jump Statements - Break and Continue.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0c422194b3c80416d91dd612aa7b34bb0fbd3688604d92bed32e47a808e4f942
+size 50604865

09 - Iteration Statements (Loops) in Java/007 Labels in Java.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df3f86d63fc059acc141b4411ce931f9c3c444246d42669aa3b5e7d7dd0821c3
+size 61053752

09 - Iteration Statements (Loops) in Java/011 Homework review Iteration Statements (Loops).mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2522b8e6587dd3c05d2ed70e5944ba7ab190e5b0291ac55d1e7e5e22d7e2d34e
+size 28394427

22 - Functional Programming in Java (including lambda functions & method references)/004 Source-code-All-examples-from-the-lecture-CONSUMERS.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/functions/consumers

22 - Functional Programming in Java (including lambda functions & method references)/004 Source-code-All-examples-from-the-lecture-PREDICATES.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/functions/predicates

22 - Functional Programming in Java (including lambda functions & method references)/external-links.txt

@@ -0,0 +1,21 @@
+
+001 Documentation-of-java.util.function-package
+https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/function/package-summary.html
+
+002 Source-code-All-examples-from-the-lecture
+https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/functions/lambdaandmethodreference
+
+003 Source-code-All-examples-from-the-lecture
+https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/functions/functionandbifunction
+
+004 Source-code-All-examples-from-the-lecture-CONSUMERS
+https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/functions/consumers
+
+004 Source-code-All-examples-from-the-lecture-PREDICATES
+https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/functions/predicates
+
+004 Homework
+https://docs.google.com/document/d/1hMA300MS2UJhRDfh5VUviGrGiQzfsV5rReH5KTwDdvc/edit?usp=sharing
+
+004 Solution-for-Homework
+https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/functions/hw

23 - Stream API/001 Documentation-for-java.util.stream-package.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/stream/package-summary.html

23 - Stream API/001 Homework-Solution-Books-Management.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/oop/hw/books

23 - Stream API/001 Homework-Solution-Filter-words-by-length.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/methods/hw/FilterStringArray.java

23 - Stream API/001 Homework-Solution-Present-Sweets.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/oop/hw/present

23 - Stream API/001 Homework.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://docs.google.com/document/d/1TLRPMHsciAdeHn8XFWXQYrO3dVGv6b_THev6nKE2ewY/edit?usp=sharing

23 - Stream API/001 Source-code-All-examples-from-the-lecture.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/functions/streams

23 - Stream API/001 Stream API with Practical Exercises_en.srt

@@ -0,0 +1,1312 @@
+1
+00:00:05,000 --> 00:00:10,000
+I know there are students in this class and we're going to discuss topics that will help to make your
+
+2
+00:00:10,000 --> 00:00:13,000
+code clean and concise while working with collections in the race.
+
+3
+00:00:14,000 --> 00:00:19,000
+They will talk about Stream API at the beginning of the lesson, will give an answer what stream API
+
+4
+00:00:19,000 --> 00:00:20,000
+is.
+
+5
+00:00:20,000 --> 00:00:26,000
+I will explain to you why we need to use three API with race and collection sometimes after this class
+
+6
+00:00:26,000 --> 00:00:31,000
+and you will understand what the conveyor belt is and what terminal and non terminal operations are.
+
+7
+00:00:32,000 --> 00:00:37,000
+You are going to learn how to create stream and how to process elements with the help of Stream API.
+
+8
+00:00:37,000 --> 00:00:40,000
+I'm going to show you really a lot of examples today.
+
+9
+00:00:40,000 --> 00:00:46,000
+I will teach you how to create a stream from array and how to convert at to map with the help of Stream
+
+10
+00:00:46,000 --> 00:00:46,000
+API.
+
+11
+00:00:46,000 --> 00:00:52,000
+In this lesson, we are going to have a lot of practice because one of the ways to understand this topic
+
+12
+00:00:52,000 --> 00:00:56,000
+better is to understand how you can apply this knowledge on practice.
+
+13
+00:00:56,000 --> 00:01:01,000
+Let's start and to start with, let's create a definition of stream API.
+
+14
+00:01:02,000 --> 00:01:07,000
+If we would open official documentation from Oracle for Jayaweera to Stream Package will see that this
+
+15
+00:01:07,000 --> 00:01:14,000
+package contains classes to support functional style operations on streams of elements such as mass
+
+16
+00:01:14,000 --> 00:01:16,000
+produced transformations, onco actions.
+
+17
+00:01:17,000 --> 00:01:22,000
+I believe for people who didn't work with streams, this definition doesn't bring a lot of clarity.
+
+18
+00:01:22,000 --> 00:01:24,000
+So let me explain you the same.
+
+19
+00:01:24,000 --> 00:01:31,000
+In more simple words, stream application programming interface is a set of interfaces that allow to
+
+20
+00:01:31,000 --> 00:01:37,000
+process elements and to perform operations with them in containers and arrays with the help of functional
+
+21
+00:01:37,000 --> 00:01:38,000
+interfaces.
+
+22
+00:01:39,000 --> 00:01:45,000
+So to perform operation on the group of elements, you can create lambda functions or use Macit references
+
+23
+00:01:45,000 --> 00:01:49,000
+that in turn significantly simplifies your code.
+
+24
+00:01:49,000 --> 00:01:50,000
+Does it make sense?
+
+25
+00:01:51,000 --> 00:01:56,000
+Now let me perform an overview of one important interface from Jowett Ustream package.
+
+26
+00:01:56,000 --> 00:02:00,000
+This will help you to understand our practice examples.
+
+27
+00:02:00,000 --> 00:02:05,000
+I would say that one of the most important interfaces is stream interface.
+
+28
+00:02:05,000 --> 00:02:11,000
+What it is for string interface represents a sequence of elements supporting sequential and parallel
+
+29
+00:02:11,000 --> 00:02:13,000
+aggregate operations.
+
+30
+00:02:13,000 --> 00:02:15,000
+This is hard to understand.
+
+31
+00:02:15,000 --> 00:02:17,000
+Believe me, I know what you feel.
+
+32
+00:02:17,000 --> 00:02:24,000
+Usually I ask my students to imagine conveyor belt and on this conveyor you have elements from your
+
+33
+00:02:24,000 --> 00:02:31,000
+collection and as a conveyor belt rolling, you take each element from it and perform any modifications
+
+34
+00:02:31,000 --> 00:02:32,000
+with it.
+
+35
+00:02:33,000 --> 00:02:38,000
+Before we dive deeper to code examples, I want you to understand, at least on a high level, the next
+
+36
+00:02:38,000 --> 00:02:39,000
+example.
+
+37
+00:02:39,000 --> 00:02:46,000
+Imagine that you have a list of products and you have a task to keep on that products that has more
+
+38
+00:02:46,000 --> 00:02:53,000
+than one thousand items in the warehouse and decrease price for these products on 10 percent.
+
+39
+00:02:53,000 --> 00:02:59,000
+This business logic should change the price for products, and this in turn should motivate customers
+
+40
+00:02:59,000 --> 00:03:03,000
+of the online store to buy these products while price is reduced.
+
+41
+00:03:04,000 --> 00:03:05,000
+How would you do that?
+
+42
+00:03:05,000 --> 00:03:08,000
+You would create the container of products.
+
+43
+00:03:08,000 --> 00:03:14,000
+Let's imagine that this is a box that is full of products and put all products on conveyor belt.
+
+44
+00:03:14,000 --> 00:03:19,000
+After that, you will check what products has more than one thousand items in warehouse.
+
+45
+00:03:20,000 --> 00:03:24,000
+You will remove from Canberra products that you are not interested in.
+
+46
+00:03:24,000 --> 00:03:29,000
+That means you have to apply a function that knows how to filter elements.
+
+47
+00:03:29,000 --> 00:03:32,000
+After that, you will modify price for each product.
+
+48
+00:03:33,000 --> 00:03:40,000
+That means you have to apply functions that modify state of the product and only after that the end
+
+49
+00:03:40,000 --> 00:03:44,000
+of the conveyor belt, you would gather all elements together back to the box.
+
+50
+00:03:45,000 --> 00:03:52,000
+Is it clear now you can understand that the functions that was applied for each element on the conveyor
+
+51
+00:03:52,000 --> 00:03:55,000
+belt, they are called non terminal also.
+
+52
+00:03:55,000 --> 00:04:02,000
+They might be called intermediate functions or it would be opportunism, conveyor operations and the
+
+53
+00:04:02,000 --> 00:04:06,000
+mass that terminate conveyor are called terminal operations.
+
+54
+00:04:07,000 --> 00:04:15,000
+We also can say that each non terminal operation at Listener to the Stream listener modifies the element
+
+55
+00:04:15,000 --> 00:04:17,000
+and pass it to another listener.
+
+56
+00:04:17,000 --> 00:04:22,000
+This is called stream processing terminal and non terminal operations.
+
+57
+00:04:22,000 --> 00:04:24,000
+Create Stream Pipeline.
+
+58
+00:04:24,000 --> 00:04:31,000
+Stream Pipeline consists of the source that is our collection of elements or array followed by intermediate
+
+59
+00:04:31,000 --> 00:04:34,000
+operations and ended with terminal operation.
+
+60
+00:04:35,000 --> 00:04:37,000
+Let's consider another case.
+
+61
+00:04:37,000 --> 00:04:39,000
+You may have multiple lists of products.
+
+62
+00:04:39,000 --> 00:04:40,000
+How it can be.
+
+63
+00:04:41,000 --> 00:04:48,000
+You have different warehouses and each warehouse contains information about the products there.
+
+64
+00:04:48,000 --> 00:04:52,000
+So you have multiple lists of products from each warehouse.
+
+65
+00:04:53,000 --> 00:04:59,000
+This may happen when Demand-Driven design of your application declares that you have type warehouse
+
+66
+00:04:59,000 --> 00:05:01,000
+that in turn can return list of products.
+
+67
+00:05:02,000 --> 00:05:08,000
+And imagine that you have a list, our houses in our example, you have a lot of their houses with products
+
+68
+00:05:09,000 --> 00:05:15,000
+we can create, can aware of their houses, but we can also have the functions that would tell how to
+
+69
+00:05:15,000 --> 00:05:20,000
+extract products from these warehouses to have conveyor of products.
+
+70
+00:05:20,000 --> 00:05:25,000
+And after that, we are going to have similar to previous example, logic will filter elements and will
+
+71
+00:05:25,000 --> 00:05:28,000
+perform price modification, I believe.
+
+72
+00:05:28,000 --> 00:05:31,000
+Now you understand what we are going to learn today.
+
+73
+00:05:32,000 --> 00:05:37,000
+We're going to learn terminal and not terminal functions to perform operations with elements in streams.
+
+74
+00:05:38,000 --> 00:05:42,000
+Now, let's look at the good examples that I prepared for this lesson.
+
+75
+00:05:42,000 --> 00:05:49,000
+To understand how streams work will start from reproducing the case that you saw on slides.
+
+76
+00:05:49,000 --> 00:05:56,000
+All classes are stored in one file to keep all examples related to this lesson grouped and to not switch
+
+77
+00:05:56,000 --> 00:05:58,000
+between the different types during the lesson.
+
+78
+00:05:58,000 --> 00:06:03,000
+Here we have a class in its price name and the amount of items in their house.
+
+79
+00:06:04,000 --> 00:06:10,000
+Also, you can see a special constructor getters and setters to string Masset for the bag and purposes.
+
+80
+00:06:11,000 --> 00:06:15,000
+And here you can see a warehouse type for the sake of our next examples.
+
+81
+00:06:15,000 --> 00:06:18,000
+This class has only one field list of products.
+
+82
+00:06:19,000 --> 00:06:24,000
+Also, there are two masses, getter and setter, to retrieve and to set products accordingly.
+
+83
+00:06:25,000 --> 00:06:27,000
+Now imagine that I have a list of products.
+
+84
+00:06:27,000 --> 00:06:34,000
+You can see that I created multiple different products here and put all of them into the list to create
+
+85
+00:06:34,000 --> 00:06:34,000
+stream.
+
+86
+00:06:34,000 --> 00:06:40,000
+From this list, I have to just go through Method Stream is the default method in collection interface.
+
+87
+00:06:41,000 --> 00:06:44,000
+So all collections have be method.
+
+88
+00:06:44,000 --> 00:06:49,000
+After we create a stream we can call intermediate operations and at least inners.
+
+89
+00:06:49,000 --> 00:06:54,000
+For example, let's reproduce a situation from the slides that we saw at the beginning of our lesson
+
+90
+00:06:55,000 --> 00:06:56,000
+I call filter method.
+
+91
+00:06:57,000 --> 00:06:58,000
+Let me open the source code of Feltham.
+
+92
+00:06:58,000 --> 00:07:06,000
+As you can see, that filter method takes predicate all intermediate functions, return the stream objects
+
+93
+00:07:06,000 --> 00:07:10,000
+that allows us to create a chain of MassArt in locations.
+
+94
+00:07:10,000 --> 00:07:16,000
+Filter message returns a stream consisting of the elements of the stream that match the given predicate.
+
+95
+00:07:17,000 --> 00:07:23,000
+That means in case predicates returns true for some element, we should keep this element in the stream.
+
+96
+00:07:24,000 --> 00:07:26,000
+Let's get back to the demo file.
+
+97
+00:07:26,000 --> 00:07:28,000
+We use simple predicate here.
+
+98
+00:07:29,000 --> 00:07:35,000
+We want to keep on our conveyor belt only products that have more than 1000 items in the warehouse.
+
+99
+00:07:36,000 --> 00:07:39,000
+After that, I want to apply function to each element.
+
+100
+00:07:40,000 --> 00:07:42,000
+I use math method for this.
+
+101
+00:07:42,000 --> 00:07:45,000
+Let me open the source code of math, Macit.
+
+102
+00:07:46,000 --> 00:07:52,000
+This message returns a stream consisting of the results of a the given function to the aliments in the
+
+103
+00:07:52,000 --> 00:07:52,000
+stream.
+
+104
+00:07:53,000 --> 00:07:59,000
+In our particular case, we modify product and we return the same product to the stream we set.
+
+105
+00:07:59,000 --> 00:08:02,000
+The new price set is ten percent less than the original.
+
+106
+00:08:02,000 --> 00:08:07,000
+One important thing to know here is that intermediate operations are lazy.
+
+107
+00:08:08,000 --> 00:08:14,000
+This means that they will be invoked only if it is necessary for the terminal operation execution.
+
+108
+00:08:14,000 --> 00:08:21,000
+Let's give you the understanding that this lambda functions will be executed only in case a terminal
+
+109
+00:08:21,000 --> 00:08:23,000
+operation and the end of the chain.
+
+110
+00:08:23,000 --> 00:08:29,000
+And now when I did everything I wanted, I want to create a collection of items that are currently on
+
+111
+00:08:29,000 --> 00:08:32,000
+the conveyor belt I call terminal function collect.
+
+112
+00:08:33,000 --> 00:08:36,000
+Let's review the source code of collect Macit here.
+
+113
+00:08:36,000 --> 00:08:39,000
+We can see that this massive tax collector as an argument.
+
+114
+00:08:40,000 --> 00:08:41,000
+But what is a collector?
+
+115
+00:08:42,000 --> 00:08:45,000
+We have only one way to learn this from the source code.
+
+116
+00:08:45,000 --> 00:08:52,000
+We can understand that collector is a specific type that accumulates input elements into mutable result
+
+117
+00:08:52,000 --> 00:08:53,000
+content.
+
+118
+00:08:54,000 --> 00:08:56,000
+But where to get the implementation of collector?
+
+119
+00:08:57,000 --> 00:09:01,000
+Usually engineers use collectors glass to get any collector that is needed.
+
+120
+00:09:02,000 --> 00:09:08,000
+Let me show you the source code of collectors glass this glass also from Jemmett Ustream package.
+
+121
+00:09:08,000 --> 00:09:13,000
+And in the Masset outline you can see that we can get different collectors.
+
+122
+00:09:13,000 --> 00:09:20,000
+The most popular, in my opinion, are the ones that are returned by the next masses to least to set
+
+123
+00:09:20,000 --> 00:09:21,000
+the map.
+
+124
+00:09:21,000 --> 00:09:26,000
+Also, you can get collectors that will collect all your elements to modify modifiable least.
+
+125
+00:09:26,000 --> 00:09:30,000
+For example, most of the masses are describing here.
+
+126
+00:09:30,000 --> 00:09:34,000
+That's why I don't see the sense into naming all of this matter.
+
+127
+00:09:35,000 --> 00:09:40,000
+Just open the source code of this class to investigate what other collectors you can use.
+
+128
+00:09:40,000 --> 00:09:47,000
+By the way, at the end of the lesson, I will leave a cheat sheet for you where I will gather all the
+
+129
+00:09:47,000 --> 00:09:50,000
+most popular masses, including the terminal functions.
+
+130
+00:09:51,000 --> 00:09:53,000
+Let's get back to our demo file.
+
+131
+00:09:53,000 --> 00:09:58,000
+In this case, I want to group all elements from my stream into the container.
+
+132
+00:09:58,000 --> 00:10:01,000
+I call collect method and pass collect the.
+
+133
+00:10:01,000 --> 00:10:10,000
+Is it a might the least Masset implication, is this example clear so you can see massive change here
+
+134
+00:10:10,000 --> 00:10:14,000
+with multiple intermediate functions and then I have one terminal operation.
+
+135
+00:10:15,000 --> 00:10:17,000
+Where did they get these intermediate masses?
+
+136
+00:10:18,000 --> 00:10:20,000
+You can open string type to investigate.
+
+137
+00:10:20,000 --> 00:10:24,000
+The rest of the masses here will review these in a minute.
+
+138
+00:10:24,000 --> 00:10:26,000
+Let me finish the example we already started.
+
+139
+00:10:27,000 --> 00:10:29,000
+Let me get back to the demo file.
+
+140
+00:10:30,000 --> 00:10:35,000
+And after I created the list, I want to print all elements to console from the new line.
+
+141
+00:10:35,000 --> 00:10:40,000
+But instead of creating foreach loop, I will use the feature of Stream API.
+
+142
+00:10:40,000 --> 00:10:43,000
+I create a stream using the variable of modified products.
+
+143
+00:10:44,000 --> 00:10:51,000
+After that, I call for each method that takes consumer as an argument and I pass mast reference here
+
+144
+00:10:51,000 --> 00:10:54,000
+out property of a system class.
+
+145
+00:10:54,000 --> 00:10:59,000
+His method printer lan that we use very often during the bargain of our programs.
+
+146
+00:10:59,000 --> 00:11:05,000
+So I just use reference to this massive let me run the program to prove you that it works.
+
+147
+00:11:05,000 --> 00:11:07,000
+And here we go.
+
+148
+00:11:07,000 --> 00:11:11,000
+You can see that I have only three products with modified price.
+
+149
+00:11:11,000 --> 00:11:12,000
+Awesome.
+
+150
+00:11:12,000 --> 00:11:14,000
+Everything works as expected.
+
+151
+00:11:15,000 --> 00:11:19,000
+Now let me reproduce the second example from our presentation.
+
+152
+00:11:19,000 --> 00:11:22,000
+Imagine that we have multiple warehouses.
+
+153
+00:11:22,000 --> 00:11:25,000
+I create a few warehouses, objects here.
+
+154
+00:11:25,000 --> 00:11:27,000
+Each warehouse has lists of products.
+
+155
+00:11:28,000 --> 00:11:32,000
+That's why I add a different list of objects to the warehouses here.
+
+156
+00:11:33,000 --> 00:11:39,000
+And imagine we have to iterate over all products to decrease price only for products that have more
+
+157
+00:11:39,000 --> 00:11:41,000
+than 1000 items.
+
+158
+00:11:41,000 --> 00:11:46,000
+First of all, I group all my warehouse objects into one list.
+
+159
+00:11:46,000 --> 00:11:49,000
+Now I create a stream out of this list.
+
+160
+00:11:49,000 --> 00:11:52,000
+After that I call flat my math.
+
+161
+00:11:53,000 --> 00:11:54,000
+What is it for?
+
+162
+00:11:54,000 --> 00:12:02,000
+This method exists to extract elements from NASA once this method will return stream consistent of the
+
+163
+00:12:02,000 --> 00:12:09,000
+result of replacing each element of the stream with the contents of a mapped stream produced by applying
+
+164
+00:12:09,000 --> 00:12:13,000
+the provided map and function to each element.
+
+165
+00:12:13,000 --> 00:12:22,000
+Is it clear will path function to this method that will produce stream of elements from each element?
+
+166
+00:12:22,000 --> 00:12:29,000
+In our particular case, we have to get products from each warehouse object and create a stream on list
+
+167
+00:12:29,000 --> 00:12:30,000
+of products.
+
+168
+00:12:30,000 --> 00:12:38,000
+Before we call this flat map method, we have conveyor belt of warehouse elements and after we called
+
+169
+00:12:38,000 --> 00:12:41,000
+flat map, we have stream of product elements.
+
+170
+00:12:41,000 --> 00:12:46,000
+Can you understand now how we can transform data in our stream?
+
+171
+00:12:46,000 --> 00:12:51,000
+After that, we are filtering and applying function to all elements.
+
+172
+00:12:51,000 --> 00:12:53,000
+Now let me show you one more thing.
+
+173
+00:12:54,000 --> 00:13:00,000
+Imagine that according to some massive contracts requirements, you have to reach an array we can call
+
+174
+00:13:00,000 --> 00:13:02,000
+to array Massud instead of collect.
+
+175
+00:13:03,000 --> 00:13:07,000
+But in case we would just call Thouret Array method, we would get array of objects.
+
+176
+00:13:08,000 --> 00:13:14,000
+What to do in this case, I have to pass the Massud that will create array of the specific types that
+
+177
+00:13:14,000 --> 00:13:15,000
+I need.
+
+178
+00:13:15,000 --> 00:13:19,000
+What method can create an array of product constructor?
+
+179
+00:13:20,000 --> 00:13:28,000
+That's why I specify type here array of product and positive reference to a constructor according to
+
+180
+00:13:28,000 --> 00:13:29,000
+syntax requirements.
+
+181
+00:13:29,000 --> 00:13:31,000
+I have to write the new keyword here.
+
+182
+00:13:32,000 --> 00:13:34,000
+Can you understand now what this meant?
+
+183
+00:13:35,000 --> 00:13:38,000
+Now Java can create object of product array.
+
+184
+00:13:39,000 --> 00:13:43,000
+After that I want to print all elements to console from new line.
+
+185
+00:13:44,000 --> 00:13:48,000
+But we have an array this time can create stream from array.
+
+186
+00:13:48,000 --> 00:13:49,000
+Yes I can.
+
+187
+00:13:50,000 --> 00:13:54,000
+I have to call stream Massud from arrays class and parse array of products there.
+
+188
+00:13:55,000 --> 00:13:59,000
+That's how easily you can create three from any array.
+
+189
+00:13:59,000 --> 00:14:06,000
+Also during the discussion of functional interfaces, I promise to show you one method and how it might
+
+190
+00:14:06,000 --> 00:14:07,000
+be helpful.
+
+191
+00:14:07,000 --> 00:14:12,000
+While working with Stream API, I'm talking about identity Masset from function type.
+
+192
+00:14:13,000 --> 00:14:19,000
+Imagine that you want to convert list of products to the map type where you're going to have product
+
+193
+00:14:19,000 --> 00:14:23,000
+name as a key and product type as a value that is mapped to this key.
+
+194
+00:14:24,000 --> 00:14:25,000
+How to do that.
+
+195
+00:14:25,000 --> 00:14:30,000
+You'll remember at the beginning of the lesson I created products placed in this example.
+
+196
+00:14:30,000 --> 00:14:35,000
+I use the same list of products, I create stream code, collect method.
+
+197
+00:14:35,000 --> 00:14:40,000
+And after that I called to map Masset from collectors' class and past two functions.
+
+198
+00:14:41,000 --> 00:14:47,000
+The first one should create keys, and the second one is a function that can create product values that
+
+199
+00:14:47,000 --> 00:14:49,000
+are associated with a specific case.
+
+200
+00:14:50,000 --> 00:14:56,000
+Taking into account, I don't need to modify a product, I should return the same product.
+
+201
+00:14:56,000 --> 00:15:00,000
+That's why I use identity MASSATA function type here.
+
+202
+00:15:00,000 --> 00:15:08,000
+Identity MassArt returns the same object, does it make sense, the last good example that I want to
+
+203
+00:15:08,000 --> 00:15:15,000
+share with you is map to end and some that I would even say that a group of mass that you will use and
+
+204
+00:15:15,000 --> 00:15:17,000
+these two are just one of many.
+
+205
+00:15:18,000 --> 00:15:23,000
+There are numerous of business cases when they need to process collection of elements and find is a
+
+206
+00:15:23,000 --> 00:15:28,000
+max price or some old values of some field or something similar.
+
+207
+00:15:29,000 --> 00:15:35,000
+To perform these operations, we have to convert our regular stream to in stream or double stream along
+
+208
+00:15:35,000 --> 00:15:36,000
+stream.
+
+209
+00:15:36,000 --> 00:15:44,000
+That's why Stream Type has such masses as map to end, map to double mapped along this massive stage
+
+210
+00:15:44,000 --> 00:15:52,000
+function as an argument then can extract some no value out of current item in stream and these masses
+
+211
+00:15:52,000 --> 00:15:56,000
+rich on specific stream type like any stream that will stream along stream.
+
+212
+00:15:57,000 --> 00:15:59,000
+These types declare new methods.
+
+213
+00:16:00,000 --> 00:16:06,000
+For example, imagine the case when you need to calculate total amount of items of all products in the
+
+214
+00:16:06,000 --> 00:16:08,000
+warehouse aggregate stream.
+
+215
+00:16:08,000 --> 00:16:14,000
+And after that cool map to Inmarsat and parse function that returns into value based on each product,
+
+216
+00:16:15,000 --> 00:16:16,000
+is that clear?
+
+217
+00:16:17,000 --> 00:16:20,000
+And after that I can call some method.
+
+218
+00:16:20,000 --> 00:16:27,000
+This mass at will sum all integers in my end stream that I received after map to Inmarsat invocation.
+
+219
+00:16:28,000 --> 00:16:35,000
+And here I bring the total items amount to consult, by the way, instead of some you can call Max mean
+
+220
+00:16:35,000 --> 00:16:38,000
+average or any other methods you would like.
+
+221
+00:16:38,000 --> 00:16:45,000
+Myside examples from this file, I also prepared a lot of other examples for you, which are the masses,
+
+222
+00:16:45,000 --> 00:16:48,000
+I believe, linked to this file in attachment to this lesson.
+
+223
+00:16:49,000 --> 00:16:54,000
+I want you to investigate these good examples by yourself after the lesson, because technical is a
+
+224
+00:16:54,000 --> 00:16:56,000
+syntax is the same.
+
+225
+00:16:56,000 --> 00:16:58,000
+And you saw already a few examples.
+
+226
+00:16:58,000 --> 00:17:01,000
+Some of the methods are used very rare.
+
+227
+00:17:01,000 --> 00:17:03,000
+Some of them are used more often.
+
+228
+00:17:03,000 --> 00:17:06,000
+We'll talk about the masses in a minute.
+
+229
+00:17:06,000 --> 00:17:12,000
+But remember that you can find any good example with any message from Stream API by searching through
+
+230
+00:17:12,000 --> 00:17:12,000
+this file.
+
+231
+00:17:13,000 --> 00:17:19,000
+Now, when you saw how you can use the masses and stream API, it is only a matter of what that you
+
+232
+00:17:19,000 --> 00:17:20,000
+want to call.
+
+233
+00:17:20,000 --> 00:17:24,000
+We cover all aspects of using stream API from the syntax standpoint.
+
+234
+00:17:24,000 --> 00:17:29,000
+Now we have to learn the masses that you might want to use while working with streams.
+
+235
+00:17:30,000 --> 00:17:32,000
+I want to show you a cheat sheet, I call it.
+
+236
+00:17:32,000 --> 00:17:37,000
+So was the main operations with streams and shared examples.
+
+237
+00:17:37,000 --> 00:17:42,000
+Remember, you can use a cheat sheet in case you forgot something on this slide.
+
+238
+00:17:42,000 --> 00:17:45,000
+You can see how you can create a stream with examples.
+
+239
+00:17:45,000 --> 00:17:47,000
+Some of them we already reviewed.
+
+240
+00:17:47,000 --> 00:17:50,000
+I'm talking about creating a stream from collections and from array.
+
+241
+00:17:51,000 --> 00:17:52,000
+Let's review other options.
+
+242
+00:17:53,000 --> 00:17:56,000
+We can create stream of elements if we want.
+
+243
+00:17:56,000 --> 00:17:59,000
+We can create stream of lines in case we read file.
+
+244
+00:18:00,000 --> 00:18:02,000
+We will learn more about this during the topic.
+
+245
+00:18:02,000 --> 00:18:04,000
+Input output streams in Java.
+
+246
+00:18:05,000 --> 00:18:08,000
+Also, as you can see here, we can create a stream from stream.
+
+247
+00:18:08,000 --> 00:18:11,000
+We can use Stream Builder to add elements.
+
+248
+00:18:11,000 --> 00:18:18,000
+And after that stream also you can invoke parallel stream that would process all elements in different
+
+249
+00:18:18,000 --> 00:18:20,000
+threats of execution.
+
+250
+00:18:20,000 --> 00:18:26,000
+Ensured parallel stream will not always bring you better performance because coordination of multiple
+
+251
+00:18:26,000 --> 00:18:30,000
+threats of execution also requires some calculations.
+
+252
+00:18:30,000 --> 00:18:35,000
+That's why use parallel stream only with the amount of data.
+
+253
+00:18:35,000 --> 00:18:41,000
+It is hard to see what should be considered as Beke because it will depend on the operations you are
+
+254
+00:18:41,000 --> 00:18:43,000
+going to perform and stream.
+
+255
+00:18:43,000 --> 00:18:49,000
+It will also depends on the type of the object that you are going to use and how big it is.
+
+256
+00:18:49,000 --> 00:18:56,000
+I would even say that in case you are not sure whether the parallel stream in some particular case always
+
+257
+00:18:56,000 --> 00:18:58,000
+opt for regular stream in such cases.
+
+258
+00:18:59,000 --> 00:19:05,000
+Also, we can create infinite sequential order stream produced by iterative application of a function
+
+259
+00:19:05,000 --> 00:19:07,000
+to an initial element.
+
+260
+00:19:08,000 --> 00:19:14,000
+Besides that, we can create an infinite sequential stream where each element is generated by the provided
+
+261
+00:19:14,000 --> 00:19:14,000
+supply.
+
+262
+00:19:15,000 --> 00:19:19,000
+In other words, we can pass a function that can generate elements and create a stream.
+
+263
+00:19:20,000 --> 00:19:24,000
+To be honest, I didn't use the last two options very often.
+
+264
+00:19:24,000 --> 00:19:28,000
+So now you know all possible ways to create stream.
+
+265
+00:19:28,000 --> 00:19:29,000
+Let's move on.
+
+266
+00:19:30,000 --> 00:19:33,000
+On this slide, you can see different intermediate methods.
+
+267
+00:19:33,000 --> 00:19:38,000
+Some of them looks familiar to you because we had examples with those masses.
+
+268
+00:19:38,000 --> 00:19:45,000
+You already know when you might want to use filter, map, map to end flatman methods, don't you?
+
+269
+00:19:45,000 --> 00:19:52,000
+You also can use skip method to skip specific number of elements you can call distant Masad to get stream
+
+270
+00:19:52,000 --> 00:19:59,000
+without duplication in case you want to apply consumer function to each element you can call peak MassArt.
+
+271
+00:19:59,000 --> 00:20:05,000
+Usually it is used for debugging purposes, the print element to console to investigate the state of
+
+272
+00:20:05,000 --> 00:20:07,000
+a stream lamet.
+
+273
+00:20:07,000 --> 00:20:11,000
+Masset allows you to limit the number of elements in your stream source.
+
+274
+00:20:12,000 --> 00:20:16,000
+It allows us to source elements in stream by natural ordering.
+
+275
+00:20:16,000 --> 00:20:22,000
+There is also overloaded version of this method that takes Comparator as an argument to define the source
+
+276
+00:20:22,000 --> 00:20:23,000
+and order.
+
+277
+00:20:23,000 --> 00:20:28,000
+Using these intermediate operations, you can do amazing things with data manipulation.
+
+278
+00:20:29,000 --> 00:20:35,000
+Let's look at the next slide and on this slide you can find a list of terminal operations.
+
+279
+00:20:35,000 --> 00:20:42,000
+Today during the demo, you saw collect Masset for each entero find first method returns, the first
+
+280
+00:20:42,000 --> 00:20:43,000
+element from stream.
+
+281
+00:20:43,000 --> 00:20:49,000
+This might be useful in case your source elements in stream and want to take the first elements after
+
+282
+00:20:49,000 --> 00:20:57,000
+sorting, find any MACIT returns, any element from stream patterns that these two methods return object
+
+283
+00:20:57,000 --> 00:20:58,000
+of type optional.
+
+284
+00:20:58,000 --> 00:21:05,000
+This is not the lesson about optional, but ensured optional is a type that is used as a container for
+
+285
+00:21:05,000 --> 00:21:10,000
+objects that may or may not contain and nonono value.
+
+286
+00:21:10,000 --> 00:21:17,000
+Also, these types introduce API to extract value from container or perform as operations in case a
+
+287
+00:21:17,000 --> 00:21:18,000
+container is empty.
+
+288
+00:21:19,000 --> 00:21:27,000
+We can call Count Massud in case we want to get a number of elements in this stream and any match non-match
+
+289
+00:21:27,000 --> 00:21:30,000
+and all march methods take predicate to return.
+
+290
+00:21:30,000 --> 00:21:31,000
+True or false?
+
+291
+00:21:32,000 --> 00:21:38,000
+I believe that it is clear from the method names that any match will return true in case at least one.
+
+292
+00:21:38,000 --> 00:21:45,000
+The elements from streamy, the conditions of predicates that we passed to this massive non-match will
+
+293
+00:21:45,000 --> 00:21:52,000
+return true in case non of elements Margitza Predicate and all March will return true only in case all
+
+294
+00:21:52,000 --> 00:21:56,000
+elements march pre-cut main and maximizers.
+
+295
+00:21:56,000 --> 00:22:03,000
+I believe these are self describing this massive state comparator as an argument for each order.
+
+296
+00:22:03,000 --> 00:22:09,000
+It must is similar to for each Massett, but it also supports order of elements in the stream.
+
+297
+00:22:10,000 --> 00:22:16,000
+Reduce mass performs reduction stream operations that allows us to produce one single result from a
+
+298
+00:22:16,000 --> 00:22:21,000
+sequence of elements in this operation usually take part three participants.
+
+299
+00:22:21,000 --> 00:22:23,000
+They are a regional element.
+
+300
+00:22:24,000 --> 00:22:26,000
+It is also called identity.
+
+301
+00:22:26,000 --> 00:22:29,000
+The second participant is an accumulator.
+
+302
+00:22:29,000 --> 00:22:36,000
+This is a function that takes two parameters, a partial result of the reduction operation and the next
+
+303
+00:22:36,000 --> 00:22:37,000
+element of the string.
+
+304
+00:22:37,000 --> 00:22:40,000
+And the third participant is a combiner.
+
+305
+00:22:40,000 --> 00:22:46,000
+This is a function that is used to combine the partial result of the reduction operation once the reduction
+
+306
+00:22:46,000 --> 00:22:52,000
+is paralyzed or when there is a mismatch between the types of the accumulator arguments and the types
+
+307
+00:22:52,000 --> 00:22:54,000
+of the accumulator implementation.
+
+308
+00:22:55,000 --> 00:23:01,000
+And I know that this can sound not clear, but don't worry about that after this lesson.
+
+309
+00:23:01,000 --> 00:23:03,000
+Take your time to investigate the examples.
+
+310
+00:23:04,000 --> 00:23:10,000
+I didn't show you this example because to be honest, this function is not used super often, really.
+
+311
+00:23:11,000 --> 00:23:16,000
+So take your time to investigate examples and feel free to ask questions in case you have any.
+
+312
+00:23:17,000 --> 00:23:19,000
+That's all what I wanted to share with you today.
+
+313
+00:23:19,000 --> 00:23:24,000
+Now let's recap what we have learned today so that we learned really a lot of things.
+
+314
+00:23:25,000 --> 00:23:26,000
+But let's try to sum it up.
+
+315
+00:23:27,000 --> 00:23:30,000
+We understand what Stream API is now.
+
+316
+00:23:30,000 --> 00:23:36,000
+We know how to create stream, how to use intermediate operations and how to use terminal operations
+
+317
+00:23:37,000 --> 00:23:38,000
+on real life examples.
+
+318
+00:23:38,000 --> 00:23:41,000
+You saw how you can apply your knowledge about Stream API.
+
+319
+00:23:41,000 --> 00:23:47,000
+Also, you got a lot of examples that you can use during the development when you need.
+
+320
+00:23:47,000 --> 00:23:49,000
+And now let me show your homework.
+
+321
+00:23:50,000 --> 00:23:52,000
+You can find multiple tasks here.
+
+322
+00:23:53,000 --> 00:23:59,000
+The important thing in each task is to implement those with the help of Stream API and functional interfaces.
+
+323
+00:24:00,000 --> 00:24:06,000
+You can practice a lot in writing your own lambda expressions and then processing elements in stream
+
+324
+00:24:06,000 --> 00:24:08,000
+read tasks attentively.
+
+325
+00:24:08,000 --> 00:24:15,000
+I edit as much details as I could in each task and remember, in case you have any question gunshy to
+
+326
+00:24:15,000 --> 00:24:17,000
+ask me that.
+
+327
+00:24:17,000 --> 00:24:20,000
+So what I have for you for today, thanks a lot for your attention.
+
+328
+00:24:20,000 --> 00:24:23,000
+Have a great day and see you in the next lesson.
+

23 - Stream API/002 Quiz Functional Programming in Java - Check yourself.html

@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>Quiz Functional Programming in Java - Check yourself</title>
+
+        <style>
+            * {
+                box-sizing: border-box;
+                margin: 0;
+                padding: 0;
+            }
+            body {
+                font-family: var(--font-stack-text);
+                font-weight: 400;
+                line-height: 1.4;
+                font-size: 1.6rem;
+                color: #2d2f31;
+            }
+            .container {
+                position: relative;
+                height: 100%;
+                overflow-y: auto;
+            }
+            .content {
+                padding: 3.2rem 4.8rem;
+                word-break: break-word;
+                max-width: 69.6rem;
+                margin: 0 auto;
+            }
+            .heading {
+                margin-bottom: 24px;
+                font-family: -apple-system, BlinkMacSystemFont, Roboto, "Segoe UI", Helvetica, Arial, sans-serif,
+                    "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+                font-weight: 700;
+                line-height: 1.2;
+                letter-spacing: 0;
+                font-size: 32px;
+                max-width: 36em;
+            }
+            .article-asset-container {
+                padding: 2.4rem;
+            }
+            .article-asset-container p {
+                font-size: 19px;
+            }
+            code {
+                background-color: #fff;
+                border: 1px solid #d1d7dc;
+                color: #b4690e;
+                font-size: 80%;
+                padding: 0.2rem 0.4rem;
+                font-family: sfmono-regular, Consolas, liberation mono, Menlo, Courier, monospace;
+            }
+            p {
+                font-weight: 400;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <div class="content">
+                <div class="heading">Quiz Functional Programming in Java - Check yourself</div>
+                <div class="article-asset-container"><p><strong>Quiz Link: </strong><a href="https://forms.gle/uYL6fghm9AJnCQfa9" rel="noopener noreferrer" target="_blank"><strong>https://forms.gle/uYL6fghm9AJnCQfa9</strong></a></p><p>The quiz doesn’t require you to log in or submit any personal information. Your data privacy is my priority.</p><p>The Quiz covers content from the following lessons:</p><ul><li><p>Functional Programming in Java - Overview</p></li><li><p>Functional Interface, Lambda Functions &amp; Method References</p></li><li><p>Function &amp; BiFunction: Theory &amp; Practice</p></li><li><p>Consumer, BiConsumer, Predicate &amp; BiPredicate</p></li><li><p>Stream API</p></li></ul><p><br></p><p><strong>Quiz Instructions:</strong></p><p>This quiz is designed to help you check your understanding of the content from the previous lessons. All questions are based only on material covered in the lessons you've already watched, so there’s no need to worry about unfamiliar topics.</p><ul><li><p>Each question has one correct answer. Select the best answer and click "Submit" when you're ready.</p></li><li><p>After submitting, you'll see your score. For each question, you earn 1 point.</p></li><li><p>Click "View Results" to see the explanations for each correct answer. Reviewing these explanations can help reinforce your understanding.</p></li><li><p>If you score below 70%, I recommend revisiting the previous lessons. However, if the explanations make sense and you’re confident in your understanding, feel free to move on.</p></li><li><p>If any explanations are unclear, please don’t hesitate to post questions in the Q&amp;A section—I’m here to help!</p></li></ul></div>
+            </div>
+        </div>
+    </body>
+</html>

23 - Stream API/external-links.txt

@@ -0,0 +1,18 @@
+
+001 Documentation-for-java.util.stream-package
+https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/util/stream/package-summary.html
+
+001 Homework
+https://docs.google.com/document/d/1TLRPMHsciAdeHn8XFWXQYrO3dVGv6b_THev6nKE2ewY/edit?usp=sharing
+
+001 Source-code-All-examples-from-the-lecture
+https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/functions/streams
+
+001 Homework-Solution-Books-Management
+https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/oop/hw/books
+
+001 Homework-Solution-Present-Sweets
+https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/oop/hw/present
+
+001 Homework-Solution-Filter-words-by-length
+https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/methods/hw/FilterStringArray.java

24 - ===== Functional Programming in Java Interview Preparation =====/001 How to be prepared for the interview.html

@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>How to be prepared for the interview</title>
+
+        <style>
+            * {
+                box-sizing: border-box;
+                margin: 0;
+                padding: 0;
+            }
+            body {
+                font-family: var(--font-stack-text);
+                font-weight: 400;
+                line-height: 1.4;
+                font-size: 1.6rem;
+                color: #2d2f31;
+            }
+            .container {
+                position: relative;
+                height: 100%;
+                overflow-y: auto;
+            }
+            .content {
+                padding: 3.2rem 4.8rem;
+                word-break: break-word;
+                max-width: 69.6rem;
+                margin: 0 auto;
+            }
+            .heading {
+                margin-bottom: 24px;
+                font-family: -apple-system, BlinkMacSystemFont, Roboto, "Segoe UI", Helvetica, Arial, sans-serif,
+                    "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+                font-weight: 700;
+                line-height: 1.2;
+                letter-spacing: 0;
+                font-size: 32px;
+                max-width: 36em;
+            }
+            .article-asset-container {
+                padding: 2.4rem;
+            }
+            .article-asset-container p {
+                font-size: 19px;
+            }
+            code {
+                background-color: #fff;
+                border: 1px solid #d1d7dc;
+                color: #b4690e;
+                font-size: 80%;
+                padding: 0.2rem 0.4rem;
+                font-family: sfmono-regular, Consolas, liberation mono, Menlo, Courier, monospace;
+            }
+            p {
+                font-weight: 400;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <div class="content">
+                <div class="heading">How to be prepared for the interview</div>
+                <div class="article-asset-container"><p>I gathered for you the most popular questions during the Java Interview in JAVA FUNCTIONAL PROGRAMMING topic. How you can be prepared for the interview?</p><p>Just read the question first. Try to answer the question by yourself. After that, compare your answer with the answer provided. Remember, that this is just a reference to the answer. Because sometimes the topic is big, and you can go really deep with your answer. In case you feel like you don’t understand what the answer is about - feel free to get back in the course and review the relevant section, and relevant lesson one more time.</p><p>Also, you are always welcome to ask your questions and I will be happy to answer. I’m sure that these questions will help you to be prepared for the JAVA FUNCTIONAL PROGRAMMING interview. You need to be ready to answer perfectly on these questions.</p><p>In case there are questions that you don't know the answers to, please, feel free to check my full and the most complete course "Java From Zero to First Job".</p><p><br></p></div>
+            </div>
+        </div>
+    </body>
+</html>

24 - ===== Functional Programming in Java Interview Preparation =====/002 Part 1 Java Functional Programming Interview - Questions and Answers.html

@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>Part 1 Java Functional Programming Interview - Questions and Answers</title>
+
+        <style>
+            * {
+                box-sizing: border-box;
+                margin: 0;
+                padding: 0;
+            }
+            body {
+                font-family: var(--font-stack-text);
+                font-weight: 400;
+                line-height: 1.4;
+                font-size: 1.6rem;
+                color: #2d2f31;
+            }
+            .container {
+                position: relative;
+                height: 100%;
+                overflow-y: auto;
+            }
+            .content {
+                padding: 3.2rem 4.8rem;
+                word-break: break-word;
+                max-width: 69.6rem;
+                margin: 0 auto;
+            }
+            .heading {
+                margin-bottom: 24px;
+                font-family: -apple-system, BlinkMacSystemFont, Roboto, "Segoe UI", Helvetica, Arial, sans-serif,
+                    "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+                font-weight: 700;
+                line-height: 1.2;
+                letter-spacing: 0;
+                font-size: 32px;
+                max-width: 36em;
+            }
+            .article-asset-container {
+                padding: 2.4rem;
+            }
+            .article-asset-container p {
+                font-size: 19px;
+            }
+            code {
+                background-color: #fff;
+                border: 1px solid #d1d7dc;
+                color: #b4690e;
+                font-size: 80%;
+                padding: 0.2rem 0.4rem;
+                font-family: sfmono-regular, Consolas, liberation mono, Menlo, Courier, monospace;
+            }
+            p {
+                font-weight: 400;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <div class="content">
+                <div class="heading">Part 1 Java Functional Programming Interview - Questions and Answers</div>
+                <div class="article-asset-container"><ul><li><p><strong>WHAT IS THE STRUCTURE OF A LAMBDA EXPRESSION?</strong></p></li></ul><p><br></p><p>The lambda expression has the following structure:</p><ul><li><p>(method params) -&gt; {lambda expression body}</p></li></ul><p><br></p><p>where</p><ul><li><p>method params - a list of input parameters separated by commas (if there are more than one parameters, they are enclosed in brackets).</p></li><li><p>operator "-&gt;" - serves as a separator between the list of parameters of our method and the body in which its implementation takes place.</p></li><li><p>lambda expression body - method body, consisting of one or more expressions enclosed in curly braces.</p></li></ul><p><br></p><p><br></p><ul><li><p><strong>WHAT VARIABLES DO LAMBDA EXPRESSIONS ACCESS TO?</strong></p></li></ul><p><br></p><p>Lambda expressions have access to the variables of the scope in which they are defined. But access is possible only if the variables are effective final, that is, either explicitly have the final modifier, or in case they do not change their value after initialization, if the variable is assigned a value for the second time, the lambda expression causes a compilation error.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS METHOD REFERENCES?</strong></p></li></ul><p><br></p><p>Method references are compact lambda expressions that allow you to pass references to methods or constructors. To do this, use the "::" keyword.</p><p>Reference methods implement a useful syntax to refer to existing methods or constructors of Java classes or objects (instances). Together with lambda expressions, reference methods make language constructs compact and concise, making it boilerplate.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT TYPES OF REFERENCES TO METHODS DO YOU KNOW?</strong></p></li></ul><p><br></p><p>There are three kinds of method references:</p><ul><li><p>Reference to a static method(ContainingClass::staticMethodName)</p></li><li><p>Reference to a concrete object method(containingObject::instanceMethodName)</p></li><li><p>Reference to constructor(ClassName::new), for generics (generics) Class&lt; T &gt;::new.</p></li></ul><p><br></p><p><br></p><ul><li><p><strong>EXPLAIN THE SYSTEM.OUT::PRINTLN EXPRESSION.</strong></p></li></ul><p><br></p><p>The System.out::println expression is a reference to the static println method of the out object of the System class, which is equivalent to the x -&gt; System.out.println(x) lambda expression.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT ARE FUNCTIONAL INTERFACES?</strong></p></li></ul><p><br></p><p>A functional interface is one that defines exactly one abstract method.</p><p><br></p><p>Java 8 introduced a new @FunctionalInterface annotation to mark an interface as functional, this annotation is used to avoid accidentally adding abstract methods to a functional interface. It's not required, but it's good coding practice.</p><p><br></p><p>Functional interfaces allow us to use lambda expressions to instantiate such interfaces.</p><p><br></p><p>The best example of a functional interface would be the java.lang.Runnable interface with a single abstract run() method. Note that an interface can include any number of default or static methods and still be functional, because default and static methods are not abstract.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT ARE STREAMS IN JAVA?</strong></p></li></ul><p><br></p><p>java.util.stream - introduced to support parallelization of computations in streams. Provides the ability to process a sequence of elements by executing one or more operations, which can be performed either sequentially or in parallel. Streams are divided into serial and parallel. The biggest benefit of this is when working with collections.</p><p><br></p><p>Operations on a stream are either intermediate or terminal. All intermediate operations return a stream, so we can combine multiple intermediate operations without using a semicolon. Terminal operations return void or a non-stream result.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE COLLECT METHOD FOR?</strong></p></li></ul><p><br></p><p>Most operations of the Stream class that modify a dataset return that dataset as a stream. However, there are situations when you would like to receive data not as a stream, but as a regular collection, for example, ArrayList or HashSet. And for this, the Stream class has a collect method. The method takes as a parameter a conversion function to a collection:</p><p>&lt;R,A&gt; R collect(Collector&lt;? super T,A,R&gt; collector)</p><p>The R parameter represents the result type of the method, the T parameter is the type of the element in the stream, and the A parameter is the type of the intermediate accumulated data. As a result, the collector parameter represents the function of converting the stream into a collection.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE DIFFERENCE BETWEEN A COLLECTION AND A STREAM?</strong></p></li></ul><p><br></p><p>The difference between a Collection (Collection) of data and a stream (Stream) from the new JDK8 is that collections allow you to work with elements individually, while a stream (Stream) does not. For example, with collections, you can add items, remove items, and insert in the middle. A Stream does not allow you to manipulate individual elements from a data set, but instead allows you to perform functions on the data as a whole.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE FOREACH METHOD IN STREAMS FOR?</strong></p></li></ul><p><br></p><p>Method void forEach(Consumer&lt;? super T&gt; action) - action is performed for each element. forEach is a terminal operation, used to iterate over each element of the stream.</p><p>forEach does not guarantee the sequence of displaying elements in a parallel stream, for this the forEachOrdered method is used - it guarantees the order.</p><p><br></p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE MAP METHOD IN STREAMS FOR?</strong></p></li></ul><p><br></p><p>Method &lt;R&gt; Stream&lt;R&gt; map(Function&lt;? super T,? extends R&gt; mapper) - converts elements of type T into elements of type R and returns a stream with elements of R.</p><p><br></p><p>map() is an intermediate operation, the method is used to convert elements to another object using the passed function.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE PURPOSE OF THE FILTER METHOD IN STREAMS?</strong></p></li></ul><p><br></p><p>Method Stream&lt;T&gt; filter(Predicate&lt;? super T&gt; predicate) - filters elements according to the condition in the predicate. filter is an intermediate operation, used to filter an array through a function.</p><p><br></p><p>In fact, filter does not perform filtering, instead it creates a new stream, which, when completed, contains the elements of the original stream that match the given predicate.</p><p><br></p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE LIMIT METHOD IN STREAMS FOR?</strong></p></li></ul><p><br></p><p>Method Stream&lt;T&gt; limit(long maxSize) - leaves only maxSize elements in the stream. limit is an intermediate operation, used to fetch the first maxSize elements of the stream. This method also returns a modified stream that has no more than maxSize elements.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE SORTED METHOD IN STREAMS FOR?</strong></p></li></ul><p><br></p><p>The Stream&lt;T&gt; sorted()/Stream&lt;T&gt; sorted(Comparator&lt;? super T&gt; comparator) method returns a sorted stream. sorted() is an intermediate operation, a method used to sort a stream using the natural order of comparison of its elements. There is also a second sorted() method that takes either a Comparable instance or its corresponding lambda expression.</p><p><br></p><p><br></p><ul><li><p><strong>PARALLEL STREAM PROCESSING IN JAVA?</strong></p></li></ul><p><br></p><p>To make a normal serial stream parallel, call the parallel method on the Stream object.</p><p><br></p><p>Alternatively, you can also use the parallelStream() method of the Collection interface to create a parallel stream from a collection.</p><p><br></p><p>At the same time, if the working machine is not multi-core, then the thread will be executed as serial.</p><p><br></p><p><br></p></div>
+            </div>
+        </div>
+    </body>
+</html>

24 - ===== Functional Programming in Java Interview Preparation =====/003 Part 2 Java Functional Programming Interview - Questions and Answers.html

@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>Part 2 Java Functional Programming Interview - Questions and Answers</title>
+
+        <style>
+            * {
+                box-sizing: border-box;
+                margin: 0;
+                padding: 0;
+            }
+            body {
+                font-family: var(--font-stack-text);
+                font-weight: 400;
+                line-height: 1.4;
+                font-size: 1.6rem;
+                color: #2d2f31;
+            }
+            .container {
+                position: relative;
+                height: 100%;
+                overflow-y: auto;
+            }
+            .content {
+                padding: 3.2rem 4.8rem;
+                word-break: break-word;
+                max-width: 69.6rem;
+                margin: 0 auto;
+            }
+            .heading {
+                margin-bottom: 24px;
+                font-family: -apple-system, BlinkMacSystemFont, Roboto, "Segoe UI", Helvetica, Arial, sans-serif,
+                    "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+                font-weight: 700;
+                line-height: 1.2;
+                letter-spacing: 0;
+                font-size: 32px;
+                max-width: 36em;
+            }
+            .article-asset-container {
+                padding: 2.4rem;
+            }
+            .article-asset-container p {
+                font-size: 19px;
+            }
+            code {
+                background-color: #fff;
+                border: 1px solid #d1d7dc;
+                color: #b4690e;
+                font-size: 80%;
+                padding: 0.2rem 0.4rem;
+                font-family: sfmono-regular, Consolas, liberation mono, Menlo, Courier, monospace;
+            }
+            p {
+                font-weight: 400;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <div class="content">
+                <div class="heading">Part 2 Java Functional Programming Interview - Questions and Answers</div>
+                <div class="article-asset-container"><ul><li><p><strong>WHAT IS THE BICONSUMER&lt;T,U&gt; FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents an operation that takes two input parameters and returns no result.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE BIFUNCTION&lt;T,U,R&gt; FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>It is a function that takes two arguments and returns a result.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE BINARYOPERATOR&lt;T&gt; FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents an operation on two operands of the same type, performs a binary operation on them, and returns a result of the same type as the operands.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE BIPREDICATE&lt;T,U&gt; FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents a predicate (boolean function) of two arguments.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE BOOLEANSUPPLIER FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents a boolean result provider.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE CONSUMER&lt;T&gt; FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents an operation that takes one input argument, performs some action on an object of type T, and returns nothing.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE DOUBLEBINARYOPERATOR FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents an operation on two operands of type double, returns a result of type double.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE DOUBLECONSUMER FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents an operation that takes one double argument and does not return a result.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE DOUBLEFUNCTION&lt;R&gt; FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents a function that takes one double argument and returns a result.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE DOUBLEPREDICATE FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p>Represents a predicate (boolean function) of one double argument.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE DOUBLESUPPLIER FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents the provider of double results.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE DOUBLETOINTFUNCTION FOR?</strong></p></li></ul><p><br></p><p>It is a function that takes one argument of type double and returns the result of type int.</p><p><br></p><p><br></p><ul><li><p><strong>WHY IS THE DOUBLETOLONGFUNCTION FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents a function that takes one argument of type double and returns a result of type long.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE DOUBLEUNARYOPERATOR FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents an operation on one argument of double type, returns a result of type double.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE FUNCTION&lt;T,R&gt; INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents a transition function from an object of type T to an object of type R.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE INTBINARYOPERATOR FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents an operation on two operands of type int, returns a result of type int.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT DOES THE INTCONSUMER FUNCTIONAL INTERFACE NEED FOR?</strong></p></li></ul><p><br></p><p>Represents an operation that takes a single int argument and returns no result.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS INTFUNCTION&lt;R&gt; FOR?</strong></p></li></ul><p><br></p><p>Represents an operation that takes one int argument and returns a result.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE INTPREDICATE FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents a predicate (boolean function) of one int argument.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT DOES THE INTSUPPLIER FUNCTIONAL INTERFACE NEED FOR?</strong></p></li></ul><p><br></p><p>Represents an int result provider.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT DOES INTTODOUBLEFUNCTION DO FOR?</strong></p></li></ul><p><br></p><p>Represents a function that takes one argument of type int and returns a result of type double.</p><p><br></p><p><br></p><ul><li><p><strong>WHY IS THE INTTOLONGFUNCTION FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents a function that takes one argument of type int and returns a result of type long.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT DOES THE INTUNARYOPERATOR FUNCTIONAL INTERFACE NEED FOR?</strong></p></li></ul><p><br></p><p>Represents an operation on a single argument of type int, returns a result of type int.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS A LONGBINARYOPERATOR FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents an operation on two operands of type long, returns a result of type long.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE LONGCONSUMER FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents an operation that takes one long argument and does not return a result.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE LONGFUNCTION&lt;R&gt; FUNCTION INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents a function that takes one long argument and returns a result.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE LONGPREDICATE FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents a predicate (boolean function) of one argument of type long.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT DOES THE LONGSUPPLIER FUNCTIONAL INTERFACE NEED FOR?</strong></p></li></ul><p><br></p><p>Represents a provider of long results.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE LONGTODOUBLEFUNCTION FUNCTION INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents a function that takes one argument of type long and returns a result of type double.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS A LONGTOINTFUNCTION FUNCTION INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents a function that takes one argument of type long and returns a result of type int.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT DOES THE LONGUNARYOPERATOR FUNCTIONAL INTERFACE NEED FOR?</strong></p></li></ul><p><br></p><p>Represents an operation on a single argument of type long, returns a result of type long.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE OBJDOUBLECONSUMER&lt;T&gt; FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents an operation that takes one argument of type object and a second of type double, and does not return a result.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE OBJINTCONSUMER&lt;T&gt; FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents an operation that takes one argument of type object and a second of type int and does not return a result.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE OBJLONGCONSUMER&lt;T&gt; FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents an operation that takes one argument of type object and a second of type long, and does not return a result.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE PREDICATE&lt;T&gt; FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents a predicate (boolean function) of one argument.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE SUPPLIER&lt;T&gt; FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents a results provider.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS TODOUBLEBIFUNCTION&lt;T,U&gt; FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>It is a function that takes two arguments and returns a result of double type.</p><p><br></p><ul><li><p><strong>WHAT IS THE TODOUBLEFUNCTION&lt;T&gt; FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>It is a function that takes one argument and returns a double result.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS TOINTBIFUNCTION&lt;T,U&gt; FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>It is a function that takes two arguments and returns an int result.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS TOINTFUNCTION&lt;T&gt; FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>It is a function that takes one argument and returns an int result.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS TOLONGBIFUNCTION&lt;T,U&gt; FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>It is a function that takes two arguments and returns a long result.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE TOLONGFUNCTION&lt;T&gt; FUNCTION INTERFACE FOR?</strong></p></li></ul><p><br></p><p>It is a function that takes one argument and returns a result of type long.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE UNARYOPERATOR&lt;T&gt; FUNCTIONAL INTERFACE FOR?</strong></p></li></ul><p><br></p><p>Represents an operation on a single operand, returns a result of the same type as the operand.</p><p><br></p><p><br></p><p><br></p></div>
+            </div>
+        </div>
+    </body>
+</html>

25 - Input and Output Streams in Java/001 Homework.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://docs.google.com/document/d/12mpGjQti9SwYrCS-0RU-WNYtEQCKSFwjgiCS8iKDnTw/edit?usp=sharing

25 - Input and Output Streams in Java/001 Input and Output Streams in Java_en.srt

@@ -0,0 +1,1900 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello, Jim.
+
+2
+00:00:06,000 --> 00:00:11,000
+They were going to loan with you how to work with inputs and outputs streams in Java.
+
+3
+00:00:11,000 --> 00:00:14,000
+We will start our lesson from learning how to work with files in Java.
+
+4
+00:00:15,000 --> 00:00:22,000
+We learned today how to create byte and input streams and also will create byte and charter output streams
+
+5
+00:00:22,000 --> 00:00:23,000
+on real examples.
+
+6
+00:00:23,000 --> 00:00:27,000
+You are going to see how to work with files with the help of Java today.
+
+7
+00:00:27,000 --> 00:00:32,000
+You are going to learn how to close resources and how to use blog driveway's resources.
+
+8
+00:00:32,000 --> 00:00:37,000
+After today's lesson, you will understand how to use different encoding while reading and writing to
+
+9
+00:00:37,000 --> 00:00:39,000
+file at the end of the lesson.
+
+10
+00:00:39,000 --> 00:00:42,000
+We will talk about classes and interfaces from Joany Your package.
+
+11
+00:00:42,000 --> 00:00:46,000
+I'll show you how you can process files with the help of Stream API.
+
+12
+00:00:46,000 --> 00:00:50,000
+You are going to learn what Buffer's dreams are and how to work with them.
+
+13
+00:00:50,000 --> 00:00:55,000
+Also, I'll share with you tasks that will help you to practice your skills of working with streams.
+
+14
+00:00:55,000 --> 00:01:03,000
+Let's start Java IO package is about reading data from a data source and writing of raw data to a destination.
+
+15
+00:01:03,000 --> 00:01:05,000
+There are various or data destinations.
+
+16
+00:01:05,000 --> 00:01:12,000
+Some of them are files by network, connections in memory buffers and so on.
+
+17
+00:01:12,000 --> 00:01:18,000
+Work with different data sources are similar from the application programming interface standpoint.
+
+18
+00:01:18,000 --> 00:01:24,000
+That's why I suggest to review all examples of input output streams while working with files.
+
+19
+00:01:24,000 --> 00:01:28,000
+We have to learn what files are and how to work with files.
+
+20
+00:01:28,000 --> 00:01:35,000
+To be honest, input output streams topic in Java is one of the most unstructured, a lot of packages,
+
+21
+00:01:35,000 --> 00:01:38,000
+a lot of Iraqis, a lot of classes and so on.
+
+22
+00:01:38,000 --> 00:01:43,000
+That's why I believe that this topic is the best way to learn it by example.
+
+23
+00:01:44,000 --> 00:01:48,000
+I prepared a lot of my files to help you understand the topic better.
+
+24
+00:01:48,000 --> 00:01:49,000
+Let me open the eclipse.
+
+25
+00:01:50,000 --> 00:01:55,000
+As I already mentioned, I think it is better to start from over here what files are and how to work
+
+26
+00:01:55,000 --> 00:01:56,000
+with them from Java.
+
+27
+00:01:57,000 --> 00:02:01,000
+I wrote a program here, let me run it and explore its output together with you.
+
+28
+00:02:02,000 --> 00:02:05,000
+In this example, we'll review time from packaged Java Io.
+
+29
+00:02:06,000 --> 00:02:08,000
+We have type to represent file.
+
+30
+00:02:08,000 --> 00:02:14,000
+I can easily create file object by calling constructor and patterns the file name to constructor and
+
+31
+00:02:14,000 --> 00:02:19,000
+then want to pay attention that we didn't create a file in file system.
+
+32
+00:02:19,000 --> 00:02:25,000
+We have just created file instant's and now we can call mascot's on this object that will help us to
+
+33
+00:02:25,000 --> 00:02:27,000
+create files in working directory.
+
+34
+00:02:27,000 --> 00:02:32,000
+The string that we gave to constructor is converted into abstract Bazzani.
+
+35
+00:02:33,000 --> 00:02:36,000
+I can create a catalog using this object.
+
+36
+00:02:36,000 --> 00:02:40,000
+In other words, I can create a folder by calling M Khadir method.
+
+37
+00:02:40,000 --> 00:02:46,000
+In case you want to create a hierarchy of folders, you can specify directories name using file past
+
+38
+00:02:46,000 --> 00:02:49,000
+separator operator and call mkdir smashup.
+
+39
+00:02:49,000 --> 00:02:56,000
+But creating programs with Java will create cross platform applications and we should use platform independent
+
+40
+00:02:56,000 --> 00:02:57,000
+characters.
+
+41
+00:02:57,000 --> 00:03:03,000
+Class file contains platform independent files separate and Kendzior returns.
+
+42
+00:03:03,000 --> 00:03:04,000
+True or false?
+
+43
+00:03:04,000 --> 00:03:07,000
+You can build a logic around this API here.
+
+44
+00:03:07,000 --> 00:03:12,000
+I will print the console file separate in one operating systems.
+
+45
+00:03:12,000 --> 00:03:13,000
+It is a backslash.
+
+46
+00:03:13,000 --> 00:03:15,000
+In other it is a slash.
+
+47
+00:03:15,000 --> 00:03:21,000
+Java will determine what operating system is used and will provide you with platform specific files.
+
+48
+00:03:21,000 --> 00:03:26,000
+Separate file also provides us with a constant firebase separator.
+
+49
+00:03:26,000 --> 00:03:29,000
+Do remember when we configure Jabel Normal computer?
+
+50
+00:03:29,000 --> 00:03:31,000
+We are to set environment.
+
+51
+00:03:31,000 --> 00:03:39,000
+Variables would change the value of past variable and as a separate that we use semicolon that is specific
+
+52
+00:03:39,000 --> 00:03:40,000
+to Windows operating system.
+
+53
+00:03:40,000 --> 00:03:45,000
+Separate that and you can see it in console in other operating system.
+
+54
+00:03:45,000 --> 00:03:51,000
+It could be a column here, by the way, talking about plot from independent characters.
+
+55
+00:03:51,000 --> 00:03:57,000
+I want to pay attention to line separate in some operating systems line separate.
+
+56
+00:03:57,000 --> 00:04:03,000
+That is a combination of characters like carriage return and new line in other operating systems.
+
+57
+00:04:03,000 --> 00:04:05,000
+It is just a new line character.
+
+58
+00:04:05,000 --> 00:04:12,000
+So whenever you need to express a new line, for example, in cases when you prepare text that should
+
+59
+00:04:12,000 --> 00:04:17,000
+be read into the file, I recommend you to use Mass from system class with name lines separator.
+
+60
+00:04:18,000 --> 00:04:22,000
+Now imagine that you have to create not directory, but just a file.
+
+61
+00:04:23,000 --> 00:04:30,000
+Imagine that content manager of our online store wants to do an expert of all products to the specific
+
+62
+00:04:30,000 --> 00:04:33,000
+file we have to create file for him.
+
+63
+00:04:33,000 --> 00:04:39,000
+At first we create file object and after that we create file by calling in mass.
+
+64
+00:04:39,000 --> 00:04:45,000
+It creates new file after this letter and I recommend you to open source code of the file class and
+
+65
+00:04:45,000 --> 00:04:47,000
+explore all of its methods.
+
+66
+00:04:48,000 --> 00:04:53,000
+But I want to show you your methods that may come in handy while working with files.
+
+67
+00:04:53,000 --> 00:04:59,000
+For example, you might always check was a file exists because it exists MassArt or you can check if
+
+68
+00:04:59,000 --> 00:05:01,000
+s specific file is directory.
+
+69
+00:05:02,000 --> 00:05:04,000
+When you need this, you are going to have.
+
+70
+00:05:04,000 --> 00:05:10,000
+Homework, where you would need to implement the program to solve real life case, you can build the
+
+71
+00:05:10,000 --> 00:05:17,000
+logic of iterating and navigate in your file system by identifying whether some specific item is a directory
+
+72
+00:05:17,000 --> 00:05:17,000
+or a file.
+
+73
+00:05:18,000 --> 00:05:24,000
+In case this item is a directory and you want iterate over all elements, you have to get files from
+
+74
+00:05:24,000 --> 00:05:27,000
+this directory to do this.
+
+75
+00:05:27,000 --> 00:05:29,000
+You can call list files Macit.
+
+76
+00:05:29,000 --> 00:05:33,000
+It will return array of files and you can work with the file array.
+
+77
+00:05:33,000 --> 00:05:37,000
+As with any other array, you can iterate over it if you need.
+
+78
+00:05:38,000 --> 00:05:43,000
+You can get absolute parts of the file by calling it absolute Balmaceda.
+
+79
+00:05:43,000 --> 00:05:47,000
+Also, you can check whether files that you have is executable.
+
+80
+00:05:48,000 --> 00:05:54,000
+For example, files with a DOT board extension, executable files on the Unix systems.
+
+81
+00:05:54,000 --> 00:06:01,000
+There are shell scripts with Dot S.H. extension, those executable too similar to the way you can check
+
+82
+00:06:01,000 --> 00:06:02,000
+what a specific item is.
+
+83
+00:06:02,000 --> 00:06:03,000
+A directory or not.
+
+84
+00:06:04,000 --> 00:06:08,000
+You can check if a specific item is a file by Colon is file Macit.
+
+85
+00:06:09,000 --> 00:06:15,000
+Sometimes the hidden files in the file system, for example, get folder of our local repository is
+
+86
+00:06:15,000 --> 00:06:16,000
+a hidden by default.
+
+87
+00:06:17,000 --> 00:06:19,000
+You can check it by colon is hidden last.
+
+88
+00:06:19,000 --> 00:06:20,000
+Is it clear.
+
+89
+00:06:21,000 --> 00:06:26,000
+Feel free to press a pause to review these matters and make sure that you understood them.
+
+90
+00:06:26,000 --> 00:06:32,000
+Also, I want to remind you that you are always welcome to ask any questions and Q&A section.
+
+91
+00:06:32,000 --> 00:06:38,000
+If you understood the masses that we have just reviewed, I suggest to move further, you know, just
+
+92
+00:06:38,000 --> 00:06:41,000
+Solly's files, MassArt, but it is overloaded.
+
+93
+00:06:41,000 --> 00:06:44,000
+Let me open the source code of this version of the Massett.
+
+94
+00:06:45,000 --> 00:06:48,000
+And right near this method we have another one.
+
+95
+00:06:48,000 --> 00:06:54,000
+This method takes file filter as an argument to filter files and return only files that that means the
+
+96
+00:06:54,000 --> 00:07:01,000
+condition that is specified in file filter lets open file filter to understand this interface better.
+
+97
+00:07:01,000 --> 00:07:07,000
+And here and the source code we can see that file filter is a functional interface assumes that by this
+
+98
+00:07:07,000 --> 00:07:13,000
+moment and now of course you already know functional programming and can understand what functional
+
+99
+00:07:13,000 --> 00:07:14,000
+interface annotation is.
+
+100
+00:07:15,000 --> 00:07:22,000
+Just to remind you, this annotation means that the interface is only one aspect Masset and we can use
+
+101
+00:07:22,000 --> 00:07:25,000
+is a massive reference or lambda function to implement this type.
+
+102
+00:07:26,000 --> 00:07:33,000
+Indeed, file filter has only one abasic Masset with name except the text file as an argument and should
+
+103
+00:07:33,000 --> 00:07:35,000
+return is a true or false.
+
+104
+00:07:35,000 --> 00:07:42,000
+Let's get back to our demo file was filed, for example, here in the example you can see that I created
+
+105
+00:07:42,000 --> 00:07:47,000
+Lambda Functions that meets the definition of accept Masset from file filter interface.
+
+106
+00:07:47,000 --> 00:07:49,000
+It takes file object and returns.
+
+107
+00:07:49,000 --> 00:07:56,000
+True or false based on it, you can see that I get filename and after that I check with a file.
+
+108
+00:07:56,000 --> 00:07:58,000
+Name is ended with Java.
+
+109
+00:07:58,000 --> 00:08:02,000
+This lambda function will return me only Java source code files.
+
+110
+00:08:03,000 --> 00:08:04,000
+Does it make sense?
+
+111
+00:08:04,000 --> 00:08:08,000
+Let me run this program to execute all the code that we have just reviewed.
+
+112
+00:08:08,000 --> 00:08:16,000
+By the way, after execution of this program, all folders are created here and here is our result since
+
+113
+00:08:16,000 --> 00:08:18,000
+we file that we also created in our program.
+
+114
+00:08:18,000 --> 00:08:26,000
+So now you can understand that the path that we specified for file here is relative and it is relative
+
+115
+00:08:26,000 --> 00:08:27,000
+to our Java project.
+
+116
+00:08:28,000 --> 00:08:30,000
+You can use absolute powers if you want.
+
+117
+00:08:30,000 --> 00:08:35,000
+The absolute pass on Windows would include your disk C and all the folders.
+
+118
+00:08:36,000 --> 00:08:39,000
+For example, here you can see absolute file pass.
+
+119
+00:08:40,000 --> 00:08:45,000
+Usually in your programs you don't want to specify absolute pass y.
+
+120
+00:08:45,000 --> 00:08:50,000
+You have to understand that your program is going to be executed on different computers and on different
+
+121
+00:08:50,000 --> 00:08:54,000
+servers and file system will look differently on each computer.
+
+122
+00:08:55,000 --> 00:08:59,000
+For example, on Unix like operating system, there is no use C at all.
+
+123
+00:09:00,000 --> 00:09:01,000
+Can you understand that?
+
+124
+00:09:01,000 --> 00:09:06,000
+That's why in real life you would usually use relative to your project.
+
+125
+00:09:06,000 --> 00:09:08,000
+Just makes sense cuz.
+
+126
+00:09:09,000 --> 00:09:16,000
+Now, I want to share with you and as a way to manipulate files besides Java, I hope there is also
+
+127
+00:09:16,000 --> 00:09:17,000
+Java new package.
+
+128
+00:09:18,000 --> 00:09:21,000
+It is called as new output input streams.
+
+129
+00:09:21,000 --> 00:09:28,000
+That's why it has end letter in the name Unions and National Review and parallel classes and types from
+
+130
+00:09:28,000 --> 00:09:29,000
+Java I.
+
+131
+00:09:29,000 --> 00:09:31,000
+O Package and classes and types from Jouni.
+
+132
+00:09:31,000 --> 00:09:32,000
+A package.
+
+133
+00:09:32,000 --> 00:09:36,000
+From the practical side, I can say that classes from both.
+
+134
+00:09:36,000 --> 00:09:39,000
+I mean I o and newer packages are used.
+
+135
+00:09:40,000 --> 00:09:42,000
+There are no specific preferences.
+
+136
+00:09:42,000 --> 00:09:46,000
+It is just a matter of APIs and how you would like to work with streams.
+
+137
+00:09:47,000 --> 00:09:50,000
+There is a way to do the same things but with different classes.
+
+138
+00:09:50,000 --> 00:09:57,000
+And we as developers should be aware of different interfaces in Java because different APIs would use
+
+139
+00:09:57,000 --> 00:09:58,000
+different types.
+
+140
+00:09:59,000 --> 00:10:04,000
+Let me open another file with examples that will help you to understand how you can manipulate with
+
+141
+00:10:04,000 --> 00:10:04,000
+files.
+
+142
+00:10:04,000 --> 00:10:10,000
+With the help of Java new package in your package, there is one important difference.
+
+143
+00:10:10,000 --> 00:10:15,000
+The concept and all API is built around Naza abstraction.
+
+144
+00:10:15,000 --> 00:10:16,000
+It is name POS.
+
+145
+00:10:17,000 --> 00:10:19,000
+You don't have a file like in Java I o package.
+
+146
+00:10:20,000 --> 00:10:27,000
+What you can do is to manipulate with a resource by its boss to create path object we have to use first
+
+147
+00:10:27,000 --> 00:10:33,000
+class was asked at the end and static method get let me open the source code of POS class.
+
+148
+00:10:34,000 --> 00:10:37,000
+This specific method takes verbal arguments.
+
+149
+00:10:37,000 --> 00:10:44,000
+You can pass one string that contains file pass separators, but also you can pass multiple strings
+
+150
+00:10:44,000 --> 00:10:51,000
+to indicate in the directories you can see that this is Ovalau, that we also have another version of
+
+151
+00:10:51,000 --> 00:10:53,000
+it to pass your right object.
+
+152
+00:10:53,000 --> 00:10:59,000
+But in my opinion, this version of get matched with variable string arguments is more popular.
+
+153
+00:10:59,000 --> 00:11:04,000
+Let's get back to the demo file and I will show you Boss API in your package.
+
+154
+00:11:04,000 --> 00:11:11,000
+There is files class that contains a lot of masses to work with files and the same as other classes
+
+155
+00:11:11,000 --> 00:11:11,000
+from John.
+
+156
+00:11:11,000 --> 00:11:19,000
+Your package, it uses POS type in its own API, the same operations that we did with the file object.
+
+157
+00:11:19,000 --> 00:11:22,000
+In the previous example, we can do with the help of files class.
+
+158
+00:11:23,000 --> 00:11:29,000
+For example, we can check whether the file behind this passes the directory or it is a regular file.
+
+159
+00:11:29,000 --> 00:11:33,000
+We can create a hierarchy of directories by and create directories.
+
+160
+00:11:33,000 --> 00:11:36,000
+Masset, you can create a file when you want.
+
+161
+00:11:36,000 --> 00:11:38,000
+We can also delete directory bytes.
+
+162
+00:11:38,000 --> 00:11:44,000
+But as you can see, you can do pretty much everything you want to do with files, with the help of
+
+163
+00:11:44,000 --> 00:11:45,000
+files class.
+
+164
+00:11:46,000 --> 00:11:52,000
+What I would recommend you also to do is to open the source code of files class and to review all of
+
+165
+00:11:52,000 --> 00:11:53,000
+its methods.
+
+166
+00:11:53,000 --> 00:11:59,000
+I believe you are smart enough already to read the documentation and to understand what each method
+
+167
+00:11:59,000 --> 00:12:04,000
+is all about, because we did that with other classes and you know how to do this.
+
+168
+00:12:04,000 --> 00:12:11,000
+And there is not so much sense to go over each method and with documentation outloud also take into
+
+169
+00:12:11,000 --> 00:12:14,000
+account we reviewed the most popular methods in my opinion.
+
+170
+00:12:14,000 --> 00:12:18,000
+So just take your time at home to review the source code of files.
+
+171
+00:12:18,000 --> 00:12:24,000
+Class by yourself, meanwhile, will go further and I will explain you the structure of input and output
+
+172
+00:12:24,000 --> 00:12:26,000
+streams now.
+
+173
+00:12:26,000 --> 00:12:30,000
+And once you understand the hierarchy of all types in Java I.
+
+174
+00:12:30,000 --> 00:12:37,000
+O package, we have two main Iraqis, Zaya Iraqiya, by streams and character streams.
+
+175
+00:12:37,000 --> 00:12:39,000
+What is the difference between them?
+
+176
+00:12:39,000 --> 00:12:43,000
+My streams can work with data with size eight bits.
+
+177
+00:12:43,000 --> 00:12:44,000
+That is one byte.
+
+178
+00:12:45,000 --> 00:12:49,000
+So all reading and writing operations work was a bit.
+
+179
+00:12:49,000 --> 00:12:56,000
+These types were created since Java creation and after that time that can process data of two bytes
+
+180
+00:12:56,000 --> 00:12:57,000
+were created.
+
+181
+00:12:57,000 --> 00:13:03,000
+Now there is a possibility to process Unicode characters and describe them in sixteen bits.
+
+182
+00:13:03,000 --> 00:13:06,000
+That is two bytes all possible.
+
+183
+00:13:06,000 --> 00:13:12,000
+The Unicode characters, definitely characters streams are used to work with text data in case you need
+
+184
+00:13:12,000 --> 00:13:14,000
+to read or write text data.
+
+185
+00:13:14,000 --> 00:13:20,000
+It is recommended to use characters streams to ensure that you can read all characters from the file
+
+186
+00:13:21,000 --> 00:13:22,000
+on the other end.
+
+187
+00:13:22,000 --> 00:13:25,000
+But streams are widely used in reading and writing resources.
+
+188
+00:13:26,000 --> 00:13:32,000
+For example, in case you want to store image in your file system, user uploaded and Avatar and you
+
+189
+00:13:32,000 --> 00:13:39,000
+want to store profile image on the file system of your server, you can transform this image and bitstream
+
+190
+00:13:39,000 --> 00:13:43,000
+and store it as a sequence of bytes on your file system and when it will be needed.
+
+191
+00:13:44,000 --> 00:13:47,000
+You can read stream of bytes to restore the image.
+
+192
+00:13:47,000 --> 00:13:48,000
+Does it make sense?
+
+193
+00:13:49,000 --> 00:13:56,000
+On the top of the bitstream, Iraqis are to abstract classes, inputs and outputs stream and there are
+
+194
+00:13:56,000 --> 00:14:03,000
+dozens of implementations classes like file input stream, Vitara input stream, object, input stream
+
+195
+00:14:03,000 --> 00:14:04,000
+and Osas.
+
+196
+00:14:04,000 --> 00:14:08,000
+If we talk about classes that extends output stream, it is worth Dimanche on such.
+
+197
+00:14:08,000 --> 00:14:16,000
+Losses as file output stream by output stream, object's output stream and osos on the top of character
+
+198
+00:14:16,000 --> 00:14:19,000
+stream, Iraqis are also to abstract classes.
+
+199
+00:14:19,000 --> 00:14:26,000
+They are reader and writer and you can see on the slides that multiple classes extended zis to all classes
+
+200
+00:14:26,000 --> 00:14:30,000
+usually have appropriate suffix reader or writer.
+
+201
+00:14:31,000 --> 00:14:33,000
+Take a look at this Iraqi press.
+
+202
+00:14:33,000 --> 00:14:38,000
+Pause for a second and make sure the slide looks clear and logical to you.
+
+203
+00:14:38,000 --> 00:14:41,000
+If you think you understood this, let's move on.
+
+204
+00:14:41,000 --> 00:14:44,000
+Let me now show you how you can work with inputs and outputs.
+
+205
+00:14:44,000 --> 00:14:45,000
+Streams.
+
+206
+00:14:46,000 --> 00:14:51,000
+I will share with you this demo file and I want you to execute these examples on your computer separately
+
+207
+00:14:52,000 --> 00:14:53,000
+and would investigate the result.
+
+208
+00:14:54,000 --> 00:14:59,000
+This will help you better understand how input and output streams work right now.
+
+209
+00:14:59,000 --> 00:15:02,000
+I walk you through these examples to share with you my thoughts.
+
+210
+00:15:03,000 --> 00:15:08,000
+At the beginning of our program, we specify a file pass that will be used as a test directory for the
+
+211
+00:15:08,000 --> 00:15:10,000
+sake of our examples.
+
+212
+00:15:10,000 --> 00:15:15,000
+And also we have here tags that contains different characters, including Cyrillic characters.
+
+213
+00:15:15,000 --> 00:15:18,000
+This will help us to understand encoding examples.
+
+214
+00:15:18,000 --> 00:15:23,000
+Let's start our first example is right, text or file.
+
+215
+00:15:23,000 --> 00:15:24,000
+With the help of BitStream.
+
+216
+00:15:25,000 --> 00:15:28,000
+We have this method here that takes path and string.
+
+217
+00:15:28,000 --> 00:15:30,000
+Let's investigate the source code.
+
+218
+00:15:30,000 --> 00:15:32,000
+I have tried finally block here.
+
+219
+00:15:32,000 --> 00:15:33,000
+Why do I need it?
+
+220
+00:15:34,000 --> 00:15:40,000
+It is a rule of thumb to close their sources once you use them because having multiple resources open
+
+221
+00:15:41,000 --> 00:15:43,000
+will make it harm to your application.
+
+222
+00:15:43,000 --> 00:15:50,000
+This could lead to resource leak to close any of inputs and outputs streams we have to call close Masset
+
+223
+00:15:50,000 --> 00:15:54,000
+on the resource to have access to output stream reference.
+
+224
+00:15:55,000 --> 00:16:02,000
+I declare it outside of the try block inside the trial block and create an instance of file output stream
+
+225
+00:16:02,000 --> 00:16:04,000
+and specify parts to the file.
+
+226
+00:16:04,000 --> 00:16:10,000
+After that, I get bytes from the string and I call write method to write bytes to the file.
+
+227
+00:16:11,000 --> 00:16:13,000
+After I did, everything I need was a resource.
+
+228
+00:16:13,000 --> 00:16:15,000
+I close it and finally block.
+
+229
+00:16:16,000 --> 00:16:18,000
+That's why I have such construction.
+
+230
+00:16:18,000 --> 00:16:20,000
+Let's proceed with the next example.
+
+231
+00:16:21,000 --> 00:16:24,000
+In the next example, there are a few more things to learn.
+
+232
+00:16:24,000 --> 00:16:28,000
+First of all, then all the construction to close the resources.
+
+233
+00:16:28,000 --> 00:16:30,000
+It is called Trivers Resources Block.
+
+234
+00:16:31,000 --> 00:16:32,000
+Let's go line by line.
+
+235
+00:16:32,000 --> 00:16:39,000
+I write right keyword and after that in parentheses, I specify resources that should be closed automatically
+
+236
+00:16:40,000 --> 00:16:42,000
+outside of the Trivers resources block.
+
+237
+00:16:42,000 --> 00:16:47,000
+All types that implements closable interface can be used in this block.
+
+238
+00:16:47,000 --> 00:16:53,000
+Let me open the source code of file output stream and here you can see that it extends output stream
+
+239
+00:16:53,000 --> 00:16:56,000
+type that in turn implements closable interface.
+
+240
+00:16:56,000 --> 00:17:01,000
+That's why this type can be placed inside thrivers resources block.
+
+241
+00:17:01,000 --> 00:17:05,000
+The next thing to learn here is using the word keyword.
+
+242
+00:17:05,000 --> 00:17:12,000
+This is exactly the case when using the keyword is justified because this is just local variable that
+
+243
+00:17:12,000 --> 00:17:15,000
+is going to be used right after its declaration.
+
+244
+00:17:15,000 --> 00:17:21,000
+That's why there is no need to declare abstract type of this variable and it can be the same as a specific
+
+245
+00:17:21,000 --> 00:17:21,000
+type.
+
+246
+00:17:22,000 --> 00:17:28,000
+For example, there is no need for me to specify output stream type for variable if I want to use buffer
+
+247
+00:17:28,000 --> 00:17:31,000
+output stream and all of its features and masses.
+
+248
+00:17:32,000 --> 00:17:38,000
+Let's talk about the next thing you can see that I create object of file output stream and Robert with
+
+249
+00:17:38,000 --> 00:17:46,000
+a type Barford output stream later one architectural partners, you are going to learn that there is
+
+250
+00:17:46,000 --> 00:17:50,000
+a create structural partan that is implemented just like this.
+
+251
+00:17:51,000 --> 00:17:55,000
+You can add new features to the object by wrapping it with new type.
+
+252
+00:17:55,000 --> 00:18:00,000
+Literally, you pass the one object as an argument to the constructor of another one.
+
+253
+00:18:01,000 --> 00:18:05,000
+In this particular case, we are adding feature of buffer writing.
+
+254
+00:18:05,000 --> 00:18:08,000
+What is a buffer buffer in the computer?
+
+255
+00:18:08,000 --> 00:18:15,000
+Science is a region of physical memory storage used to temporarily store data while it is being moved
+
+256
+00:18:15,000 --> 00:18:22,000
+from one place to another buffer to either use memory efficiently by writing everything to the buffer
+
+257
+00:18:22,000 --> 00:18:26,000
+first and after that right and everything to the target at once.
+
+258
+00:18:27,000 --> 00:18:33,000
+This is considered more efficient than to perform right operations to the destination file back by byte.
+
+259
+00:18:34,000 --> 00:18:38,000
+Can you understand now why we might want to use buffer inputs and outputs streams?
+
+260
+00:18:39,000 --> 00:18:46,000
+And now I can write all string to the file outside of the TRIVERS resources block buffer is flushed
+
+261
+00:18:46,000 --> 00:18:47,000
+automatically.
+
+262
+00:18:48,000 --> 00:18:51,000
+There is one more thing you have to know about the buffer.
+
+263
+00:18:51,000 --> 00:18:58,000
+It is flashed automatically into cases when maximum size of the buffer is reached and the second case
+
+264
+00:18:58,000 --> 00:18:59,000
+is when stream is closed.
+
+265
+00:19:00,000 --> 00:19:06,000
+That means that in case you wrote, just not so much information to the buffer and you forgot to close
+
+266
+00:19:06,000 --> 00:19:06,000
+the buffer.
+
+267
+00:19:07,000 --> 00:19:10,000
+You will write Nassan to the file in the next Masset.
+
+268
+00:19:10,000 --> 00:19:12,000
+You can see exactly this case.
+
+269
+00:19:13,000 --> 00:19:19,000
+Let me comment on matters that are called after this one and now I can run the program.
+
+270
+00:19:20,000 --> 00:19:25,000
+Now, when program is executed, I want to check output file just as directory.
+
+271
+00:19:26,000 --> 00:19:32,000
+And here is how a demo text file you can see that is empty because Buffer is not flushed.
+
+272
+00:19:33,000 --> 00:19:35,000
+Now let's get back to our demo file.
+
+273
+00:19:35,000 --> 00:19:39,000
+And I vividly called Flash Masset to phlogiston buffer.
+
+274
+00:19:39,000 --> 00:19:41,000
+I execute the program one more time.
+
+275
+00:19:42,000 --> 00:19:45,000
+And if we would look to our output file where.
+
+276
+00:19:45,000 --> 00:19:52,000
+And to find that the tax was successfully written and you understand now what Buffer is, you can investigate
+
+277
+00:19:52,000 --> 00:19:54,000
+the source code to learn more.
+
+278
+00:19:54,000 --> 00:20:00,000
+For example, let me open bar for output stream and to explore its close method together with you.
+
+279
+00:20:01,000 --> 00:20:06,000
+There is no closed Manhattan buffer at output stream because it is implemented in the parent type.
+
+280
+00:20:07,000 --> 00:20:10,000
+Lets open parent type and find close massive here.
+
+281
+00:20:10,000 --> 00:20:11,000
+Awesome.
+
+282
+00:20:11,000 --> 00:20:12,000
+Here it is.
+
+283
+00:20:13,000 --> 00:20:18,000
+And you can see that during the closing of this resource flash, it is called automatically.
+
+284
+00:20:18,000 --> 00:20:25,000
+That is exactly the reason why we can see that text was written in the file in case we use Buffer,
+
+285
+00:20:25,000 --> 00:20:32,000
+its output stream with strivings resources block because close method is called automatically for all
+
+286
+00:20:32,000 --> 00:20:34,000
+resources specified in Trie lock.
+
+287
+00:20:35,000 --> 00:20:36,000
+Does it make more sense now?
+
+288
+00:20:36,000 --> 00:20:37,000
+Great.
+
+289
+00:20:37,000 --> 00:20:38,000
+Let's move on.
+
+290
+00:20:38,000 --> 00:20:42,000
+And before we proceed, let me comment on other matters.
+
+291
+00:20:42,000 --> 00:20:42,000
+Cool.
+
+292
+00:20:43,000 --> 00:20:47,000
+We'll review the next examples a little bit faster because they are similar.
+
+293
+00:20:47,000 --> 00:20:52,000
+These examples shows us how to write to the file with character streams.
+
+294
+00:20:52,000 --> 00:20:53,000
+We just create file, right?
+
+295
+00:20:53,000 --> 00:20:55,000
+An object that extends right to type.
+
+296
+00:20:56,000 --> 00:21:01,000
+By the way, I believe you understood that you can use any other type besides those that works with
+
+297
+00:21:01,000 --> 00:21:02,000
+files.
+
+298
+00:21:02,000 --> 00:21:07,000
+The way how you will use those types are pretty similar to the way how you use types that work with
+
+299
+00:21:07,000 --> 00:21:08,000
+files.
+
+300
+00:21:08,000 --> 00:21:12,000
+So just feel free to use any implementations of input.
+
+301
+00:21:12,000 --> 00:21:15,000
+Stream output stream reader and writer.
+
+302
+00:21:15,000 --> 00:21:22,000
+Classis example was Bufford writer a similar pay attention that in these matters you can pass a whole
+
+303
+00:21:22,000 --> 00:21:24,000
+string to the method instead of array of bytes.
+
+304
+00:21:25,000 --> 00:21:28,000
+Make sure you understood these examples before moving further.
+
+305
+00:21:28,000 --> 00:21:29,000
+If you.
+
+306
+00:21:29,000 --> 00:21:30,000
+OK, let's proceed.
+
+307
+00:21:31,000 --> 00:21:38,000
+Now, let me show you next examples, these examples about reading from file, the first example shows
+
+308
+00:21:38,000 --> 00:21:41,000
+us how to read from a file with the help of BitStream.
+
+309
+00:21:41,000 --> 00:21:47,000
+As you can see, we create an object of file input stream in Shrivers resources block.
+
+310
+00:21:47,000 --> 00:21:52,000
+Here you can see that I read file by Might's until I would face with minus one.
+
+311
+00:21:52,000 --> 00:21:58,000
+That would mean I reached the end of the file and print Arrison to console.
+
+312
+00:21:58,000 --> 00:22:03,000
+I have to convert integer variable to char but during the reading of files was bitstream.
+
+313
+00:22:04,000 --> 00:22:05,000
+You're going to face one issue.
+
+314
+00:22:06,000 --> 00:22:11,000
+You will be able to read on the first two hundred fifty six characters from Unicode Table.
+
+315
+00:22:11,000 --> 00:22:15,000
+That means you won't be able to read Cyrillic symbols.
+
+316
+00:22:15,000 --> 00:22:20,000
+For example, let me run the program to show you this UNcancel output.
+
+317
+00:22:20,000 --> 00:22:26,000
+You can see that also religious symbols are turned into question marks because it is not possible to
+
+318
+00:22:26,000 --> 00:22:28,000
+represent all symbols of Unicode with one bite.
+
+319
+00:22:29,000 --> 00:22:31,000
+You need two bytes for this.
+
+320
+00:22:31,000 --> 00:22:35,000
+The next example is an example of Barford in between.
+
+321
+00:22:36,000 --> 00:22:42,000
+Here you can see that you can declare multiple resources and add different features to a stream by wrapping
+
+322
+00:22:42,000 --> 00:22:43,000
+it in different objects.
+
+323
+00:22:44,000 --> 00:22:48,000
+For example, data input stream allows you to read specific data type.
+
+324
+00:22:49,000 --> 00:22:55,000
+It declares additional masses like retained, for example, as returns in value and so on.
+
+325
+00:22:56,000 --> 00:23:02,000
+And you can see and understand how to add additional features to existing stream.
+
+326
+00:23:02,000 --> 00:23:05,000
+You have to create some base stream first.
+
+327
+00:23:05,000 --> 00:23:09,000
+And after that, Robert was othertimes in adolescence.
+
+328
+00:23:09,000 --> 00:23:12,000
+Will these architectural patterns in details?
+
+329
+00:23:13,000 --> 00:23:19,000
+I believe you can also understand that you can declare each object in a new line, but also you can
+
+330
+00:23:19,000 --> 00:23:24,000
+get reference only to the last object by calling constructor of different types in one line.
+
+331
+00:23:25,000 --> 00:23:28,000
+Take into account this is Bufford input stream.
+
+332
+00:23:28,000 --> 00:23:32,000
+We can read file not bound by byte, but by lines.
+
+333
+00:23:32,000 --> 00:23:35,000
+That's why Red Line MassArt is available for us here.
+
+334
+00:23:36,000 --> 00:23:41,000
+It is crossed because according to the official documentation, it is deprecated and it is recommended
+
+335
+00:23:41,000 --> 00:23:44,000
+to use characters streams to read files.
+
+336
+00:23:44,000 --> 00:23:46,000
+This is exactly what we have already discussed.
+
+337
+00:23:47,000 --> 00:23:54,000
+And below you can see two maps that show how to read file with characters, streams with buffer reader.
+
+338
+00:23:54,000 --> 00:23:55,000
+You can read file by lines.
+
+339
+00:23:56,000 --> 00:23:59,000
+Please explore these examples by yourself after the lesson.
+
+340
+00:24:00,000 --> 00:24:05,000
+From the syntax standpoint, there is nothing special just using of different types.
+
+341
+00:24:05,000 --> 00:24:10,000
+By the way, in console output you can see that Cyrillic symbols are read properly with the help of
+
+342
+00:24:10,000 --> 00:24:14,000
+characters symbols and there are no more question marks.
+
+343
+00:24:14,000 --> 00:24:20,000
+Now I want to show you how to perform the same operations, but with the help of type from Jowett in
+
+344
+00:24:20,000 --> 00:24:28,000
+your package, you can easily right next to the file with the help of Files Class Just Goldreich MassArt
+
+345
+00:24:28,000 --> 00:24:30,000
+and pass the next arguments.
+
+346
+00:24:30,000 --> 00:24:32,000
+The first argument is a pass object.
+
+347
+00:24:33,000 --> 00:24:40,000
+You already know how to get past object after that pass bytes that you want to write and after that
+
+348
+00:24:40,000 --> 00:24:42,000
+you can optionally pass open options.
+
+349
+00:24:43,000 --> 00:24:45,000
+Let me open the source code of rights, Macit.
+
+350
+00:24:46,000 --> 00:24:51,000
+You can see that there is variable lengths argument of the type open option.
+
+351
+00:24:51,000 --> 00:24:57,000
+That means you can either pass nothing or multiple open options would open option type s.
+
+352
+00:24:58,000 --> 00:24:59,000
+Let me open this interface.
+
+353
+00:25:00,000 --> 00:25:06,000
+This is markhor interface that declares a type that can tell program how to open or create file.
+
+354
+00:25:06,000 --> 00:25:10,000
+I press F for key to see implementations of this type.
+
+355
+00:25:11,000 --> 00:25:14,000
+The most popular in my opinion, is standard open options.
+
+356
+00:25:15,000 --> 00:25:16,000
+Let me open it.
+
+357
+00:25:16,000 --> 00:25:19,000
+This is an informal type that declares main options.
+
+358
+00:25:19,000 --> 00:25:27,000
+How to open access to the file user you want to open, only read the access to the file or also write
+
+359
+00:25:27,000 --> 00:25:27,000
+access.
+
+360
+00:25:27,000 --> 00:25:31,000
+You can specify that you want to add tags to the bottom of the file.
+
+361
+00:25:32,000 --> 00:25:33,000
+By using append option.
+
+362
+00:25:34,000 --> 00:25:37,000
+You can create a file before writing new information there.
+
+363
+00:25:37,000 --> 00:25:41,000
+To do this, we have to pass truncate existant option.
+
+364
+00:25:41,000 --> 00:25:46,000
+If we want to create file, we have to pass create option in case we want to get failer.
+
+365
+00:25:46,000 --> 00:25:50,000
+In case file already exists, we have to use create new option.
+
+366
+00:25:51,000 --> 00:25:55,000
+This is important when you're afraid accidentally overwrite already created file.
+
+367
+00:25:55,000 --> 00:25:58,000
+I believe that delete unclosed is self describing.
+
+368
+00:25:59,000 --> 00:25:59,000
+In my opinion.
+
+369
+00:25:59,000 --> 00:26:02,000
+Those are the main options that we might want to use.
+
+370
+00:26:02,000 --> 00:26:06,000
+You can review documentation for the rest of the options by yourself.
+
+371
+00:26:06,000 --> 00:26:08,000
+Let's get back now to the demo file.
+
+372
+00:26:08,000 --> 00:26:15,000
+And in our practical case, I specify that I want to create file in case it doesn't exist and append
+
+373
+00:26:15,000 --> 00:26:17,000
+tax to the bottom of the file.
+
+374
+00:26:17,000 --> 00:26:18,000
+Is that clear?
+
+375
+00:26:18,000 --> 00:26:19,000
+Great.
+
+376
+00:26:19,000 --> 00:26:23,000
+Also, in case you have a list of things, you can write them to the file.
+
+377
+00:26:23,000 --> 00:26:26,000
+Each string from the list will be written from the new line.
+
+378
+00:26:27,000 --> 00:26:30,000
+Right method is overloaded and you can also specify in.
+
+379
+00:26:31,000 --> 00:26:37,000
+In case you want to write to the file with UTF eight and Cordin just use Constant from Standard Chartered
+
+380
+00:26:37,000 --> 00:26:43,000
+class, the next example shows us how we can read from the file with the help of Joe.
+
+381
+00:26:43,000 --> 00:26:50,000
+In your package, you read file with the help of the stream lines, mistakes pass and optionally you
+
+382
+00:26:50,000 --> 00:26:56,000
+can pass and code and to read from file and when you have stream you can work with it.
+
+383
+00:26:56,000 --> 00:27:01,000
+Likewise, in your regular stream where each string is, each line from the file is as clear.
+
+384
+00:27:02,000 --> 00:27:08,000
+In our particular case, I passed the reference to the masses that can print each line from the new
+
+385
+00:27:08,000 --> 00:27:09,000
+line to console.
+
+386
+00:27:09,000 --> 00:27:12,000
+And here you can see content of the file income.
+
+387
+00:27:12,000 --> 00:27:19,000
+So you can see that the last time when we wrote an array of characters, we overwrite everything that
+
+388
+00:27:19,000 --> 00:27:26,000
+we had that here in command line you can see that we could use lambda function, but I believe you already
+
+389
+00:27:26,000 --> 00:27:28,000
+know how to use functional programming.
+
+390
+00:27:29,000 --> 00:27:32,000
+There is also another way to read content from the file.
+
+391
+00:27:32,000 --> 00:27:35,000
+There is a massive call called Read All Lines.
+
+392
+00:27:35,000 --> 00:27:37,000
+It returns list of strings.
+
+393
+00:27:37,000 --> 00:27:43,000
+The specifics of this method is that all file content will be stored in Java memory.
+
+394
+00:27:43,000 --> 00:27:49,000
+For example, in case you want to process huge files that contains tons of information.
+
+395
+00:27:49,000 --> 00:27:54,000
+Imagine that you want a process to gigabytes of information that contains information about patients
+
+396
+00:27:54,000 --> 00:27:58,000
+from all hospitals around all United States from the last 10 years.
+
+397
+00:27:59,000 --> 00:28:05,000
+And imagine that you have only one gigabyte memory reserved for Heap's base of your Java program.
+
+398
+00:28:05,000 --> 00:28:12,000
+That means you will face with error during programming execution because all text data will be stored
+
+399
+00:28:12,000 --> 00:28:14,000
+in memory of Java program.
+
+400
+00:28:14,000 --> 00:28:20,000
+But you won't face without a memory error in case you would process file stream because it reads file
+
+401
+00:28:20,000 --> 00:28:21,000
+line by line.
+
+402
+00:28:22,000 --> 00:28:28,000
+Always remember that reading and writing operations that can block threat of execution, for example,
+
+403
+00:28:28,000 --> 00:28:30,000
+in this particular case was read.
+
+404
+00:28:30,000 --> 00:28:37,000
+The main threat of execution will be stopped in this line until all file will be read.
+
+405
+00:28:37,000 --> 00:28:40,000
+That's why we're often separate.
+
+406
+00:28:40,000 --> 00:28:44,000
+Threat of execution is used to read or to read information from the file.
+
+407
+00:28:44,000 --> 00:28:46,000
+How to create a separate threat.
+
+408
+00:28:46,000 --> 00:28:51,000
+You are going to learn a little bit later when we'll get this and we'll just read in topic.
+
+409
+00:28:51,000 --> 00:28:54,000
+If you understood this example, let's move on.
+
+410
+00:28:55,000 --> 00:28:56,000
+You're all examples today.
+
+411
+00:28:56,000 --> 00:28:58,000
+You saw that specify in coding.
+
+412
+00:28:58,000 --> 00:29:01,000
+I use special clause that contains a few constants.
+
+413
+00:29:01,000 --> 00:29:03,000
+It is called standard charge sets.
+
+414
+00:29:04,000 --> 00:29:08,000
+Let me open the source code of this class in class outline.
+
+415
+00:29:08,000 --> 00:29:12,000
+You can see that it contains a very limited amount of charge sets.
+
+416
+00:29:12,000 --> 00:29:16,000
+What to do in case you need to specify some custom encoding.
+
+417
+00:29:16,000 --> 00:29:20,000
+You can create object of which are set by the specific charge set name.
+
+418
+00:29:20,000 --> 00:29:24,000
+To do this you can use for name method of charge.
+
+419
+00:29:24,000 --> 00:29:31,000
+That class you have to parse and code name to this method to get exactly charge said that you expect,
+
+420
+00:29:31,000 --> 00:29:37,000
+in case you would like to explore all available charge sets, you can print them to console charge.
+
+421
+00:29:37,000 --> 00:29:43,000
+That class has available charge sets, methods that can return sorted map of jerseyed name mapped to
+
+422
+00:29:43,000 --> 00:29:44,000
+charge that objects.
+
+423
+00:29:45,000 --> 00:29:50,000
+If you understood this, I want to show you a few more interesting matters that will be helpful during
+
+424
+00:29:50,000 --> 00:29:54,000
+your homework and hopefully during your career files.
+
+425
+00:29:54,000 --> 00:30:00,000
+Mercedez has find methods that can help you to find files that match specific condition and you can
+
+426
+00:30:00,000 --> 00:30:02,000
+create a stream out of these files.
+
+427
+00:30:02,000 --> 00:30:06,000
+But to be more specific, you can create a stream for past objects.
+
+428
+00:30:07,000 --> 00:30:13,000
+To do this, you can go find Masset and pass it, pass where you want to start looking from and into
+
+429
+00:30:13,000 --> 00:30:15,000
+value of daps.
+
+430
+00:30:15,000 --> 00:30:20,000
+That is how deep we should go into inner directories while looking for files.
+
+431
+00:30:21,000 --> 00:30:28,000
+And the key argument you have to pass by predicate that will define the logic, what file you are looking
+
+432
+00:30:28,000 --> 00:30:32,000
+for, the byproduct to expose and file attributes.
+
+433
+00:30:32,000 --> 00:30:39,000
+You can see that in this lambda function we use only POS and we want to find all files with Java extension.
+
+434
+00:30:40,000 --> 00:30:43,000
+After that, I use the stream to process all posts.
+
+435
+00:30:44,000 --> 00:30:45,000
+I saw them after that.
+
+436
+00:30:45,000 --> 00:30:50,000
+A turn parser object to string and collect all strings in one line.
+
+437
+00:30:50,000 --> 00:30:57,000
+And in case I found such files and final string is not now and it is not empty, I printed tokens.
+
+438
+00:30:57,000 --> 00:30:59,000
+So can you understand this?
+
+439
+00:30:59,000 --> 00:31:05,000
+You're always welcome to ask questions and Q&A section in case something is still unclear.
+
+440
+00:31:05,000 --> 00:31:12,000
+The results and other helpful Macit you can iterate over all files by calling Walk Masset the different
+
+441
+00:31:12,000 --> 00:31:14,000
+variations of these method.
+
+442
+00:31:14,000 --> 00:31:17,000
+One of them also allows you to set daps during the iteration.
+
+443
+00:31:18,000 --> 00:31:22,000
+This massive returns you stream and you can process it as you wish.
+
+444
+00:31:23,000 --> 00:31:25,000
+That's all what I wanted to share with you today.
+
+445
+00:31:26,000 --> 00:31:28,000
+Let's recap what we have learned today.
+
+446
+00:31:29,000 --> 00:31:31,000
+Today, we learned how to work with files.
+
+447
+00:31:32,000 --> 00:31:36,000
+We also learned how to work with type from jail new package.
+
+448
+00:31:36,000 --> 00:31:41,000
+After that, we learned what bite and character streams are after this lesson.
+
+449
+00:31:41,000 --> 00:31:44,000
+You know how to use thrivers resources block.
+
+450
+00:31:44,000 --> 00:31:50,000
+Now, you know what is a buffer and how to use buffer streams on real examples.
+
+451
+00:31:50,000 --> 00:31:53,000
+You saw how to use and call you in writing and reading.
+
+452
+00:31:53,000 --> 00:31:59,000
+And at the end of the lesson, we learned how to read and write from files with the help of Jouni,
+
+453
+00:31:59,000 --> 00:32:00,000
+your package.
+
+454
+00:32:01,000 --> 00:32:03,000
+Now I want to share with you your homework.
+
+455
+00:32:04,000 --> 00:32:08,000
+I mean, do your homework and attachments, your homework.
+
+456
+00:32:08,000 --> 00:32:12,000
+It is recommended to implement the next task to make sure that you learned this topic.
+
+457
+00:32:13,000 --> 00:32:18,000
+I want you to review the documentation for Java I o package, including file class.
+
+458
+00:32:19,000 --> 00:32:24,000
+Similar to that, I want you to review documentation for Java in your package, including files class
+
+459
+00:32:24,000 --> 00:32:27,000
+that is located in the same package file.
+
+460
+00:32:28,000 --> 00:32:32,000
+Also you have for coding exercises to implement according to the task.
+
+461
+00:32:32,000 --> 00:32:37,000
+Number three, you have to implement MassArt that would read configuration map and would be able to
+
+462
+00:32:37,000 --> 00:32:41,000
+reach an value of the specific property from the config map.
+
+463
+00:32:41,000 --> 00:32:46,000
+And the task number for you would need to iterate over files to calculate the number of files with a
+
+464
+00:32:46,000 --> 00:32:49,000
+specific extension in the exercise.
+
+465
+00:32:49,000 --> 00:32:56,000
+Number five, you have to implement console text editor, user can interact with console to write text
+
+466
+00:32:56,000 --> 00:32:58,000
+to the file and the exercise.
+
+467
+00:32:58,000 --> 00:33:00,000
+Number six is the most interesting in my opinion.
+
+468
+00:33:01,000 --> 00:33:06,000
+As you already understood along, of course, we are going to implement online store application and
+
+469
+00:33:06,000 --> 00:33:13,000
+add additional features to it as we learn new topics in this exercise and of you to add functionality
+
+470
+00:33:13,000 --> 00:33:16,000
+of storing users and products in the file.
+
+471
+00:33:16,000 --> 00:33:23,000
+That will be our first external data storage and one program will be started will read the state from
+
+472
+00:33:23,000 --> 00:33:28,000
+the files that said they are going to have a lot of opportunities to shape your skills.
+
+473
+00:33:29,000 --> 00:33:30,000
+Thanks a lot for your attention.
+
+474
+00:33:30,000 --> 00:33:34,000
+The students hope you found this lesson interesting and useful for you.
+
+475
+00:33:35,000 --> 00:33:36,000
+See you in the next lesson.
+

25 - Input and Output Streams in Java/001 Solution-of-Homework-Online-store-with-data-storage.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/finaltask/storage

25 - Input and Output Streams in Java/001 Solution-of-homework.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/io/hw

25 - Input and Output Streams in Java/001 Source-code-examples-from-lesson.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/io

25 - Input and Output Streams in Java/005 Homework-solution.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/finaltask/storage/impl/DefaultUserStoringService.java

25 - Input and Output Streams in Java/005 Homework.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://docs.google.com/document/d/1gAwAtOMhaQOCIhc_QM8XreCn_QThfOxAKmw-ufTCk7Y/edit?usp=sharing

25 - Input and Output Streams in Java/005 Serialization and Cloning_en.srt

@@ -0,0 +1,1096 @@
+1
+00:00:05,000 --> 00:00:11,000
+Hello, there are students in this lesson, we are going to learn what serialisation is and talk about
+
+2
+00:00:11,000 --> 00:00:15,000
+Object Clonan, we'll start from understanding why do we need signalization?
+
+3
+00:00:15,000 --> 00:00:21,000
+I will explain you what the serializable interface for after that unreal example.
+
+4
+00:00:21,000 --> 00:00:22,000
+We'll try to serialize.
+
+5
+00:00:22,000 --> 00:00:27,000
+And the last few objects also will learn Externalisation.
+
+6
+00:00:27,000 --> 00:00:33,000
+Today you're going to find what the difference between serializable and externalising is.
+
+7
+00:00:33,000 --> 00:00:39,000
+Once you learn that, we'll talk about object and we'll review what is deep and shallow.
+
+8
+00:00:39,000 --> 00:00:44,000
+Clonan, I'll tell you how to override clone method to support Deep Clonan.
+
+9
+00:00:44,000 --> 00:00:47,000
+In this lesson, you're going to see a lot of examples.
+
+10
+00:00:48,000 --> 00:00:49,000
+So let's start.
+
+11
+00:00:50,000 --> 00:00:53,000
+First of all, let me give the answer and question.
+
+12
+00:00:53,000 --> 00:00:55,000
+What serialisation is serialisation?
+
+13
+00:00:55,000 --> 00:00:59,000
+Is a process of converting objects to a stream of bytes.
+
+14
+00:00:59,000 --> 00:01:03,000
+Decimalization is a process of converting stream of bytes to an object.
+
+15
+00:01:04,000 --> 00:01:08,000
+In simple words, you can represent your Java object in sequence of bytes.
+
+16
+00:01:09,000 --> 00:01:15,000
+After that, you can either store it on local computer or centralized object over Internet.
+
+17
+00:01:15,000 --> 00:01:16,000
+It's up to you.
+
+18
+00:01:16,000 --> 00:01:19,000
+In case you understood what serialization is.
+
+19
+00:01:19,000 --> 00:01:23,000
+Let's understand the problem and why we might want to use terrorization.
+
+20
+00:01:24,000 --> 00:01:28,000
+To help you understand this, I'm going to discuss with you a few real life cases.
+
+21
+00:01:28,000 --> 00:01:35,000
+Imagine that you have to service that are in the same code and you need pass information from one machine
+
+22
+00:01:35,000 --> 00:01:36,000
+to another.
+
+23
+00:01:36,000 --> 00:01:43,000
+You can create an object and serialize it and pass a sequence of bytes over the network to another server.
+
+24
+00:01:44,000 --> 00:01:50,000
+The second server will decentralize your message and construct a new object out of the bytes that we
+
+25
+00:01:50,000 --> 00:01:51,000
+have sent.
+
+26
+00:01:51,000 --> 00:01:55,000
+That's how you can pass information from one server to another.
+
+27
+00:01:56,000 --> 00:01:57,000
+Another example.
+
+28
+00:01:57,000 --> 00:02:00,000
+It's when you need to store some data on the local computer.
+
+29
+00:02:00,000 --> 00:02:06,000
+Imagine that you have a game or another desktop application, for example, your diary.
+
+30
+00:02:06,000 --> 00:02:13,000
+And when the user close the program you want to say is a state of the program, it could be game progress,
+
+31
+00:02:13,000 --> 00:02:15,000
+a list of users plans.
+
+32
+00:02:15,000 --> 00:02:16,000
+It doesn't matter.
+
+33
+00:02:16,000 --> 00:02:20,000
+And you can serialize objects that contains this information.
+
+34
+00:02:20,000 --> 00:02:23,000
+One program is closed and decentralized.
+
+35
+00:02:23,000 --> 00:02:24,000
+That one program has started again.
+
+36
+00:02:25,000 --> 00:02:26,000
+It is pretty convenient, don't you think?
+
+37
+00:02:26,000 --> 00:02:33,000
+So one more practical need for serialization is to make an exact copy of an object.
+
+38
+00:02:33,000 --> 00:02:39,000
+Today we'll talk about this and you learn how to clone object with the help of civilization mechanism.
+
+39
+00:02:40,000 --> 00:02:43,000
+How else you can use a translation mechanism.
+
+40
+00:02:43,000 --> 00:02:48,000
+Imagine that you have really huge objects that takes ten minutes to construct.
+
+41
+00:02:48,000 --> 00:02:54,000
+Just imagine that it is better for you to cache this object because this resolution of this object will
+
+42
+00:02:54,000 --> 00:02:56,000
+take up to ten seconds, for example.
+
+43
+00:02:56,000 --> 00:03:00,000
+So sometimes you may want to cacio objects.
+
+44
+00:03:01,000 --> 00:03:04,000
+These are just a few examples when you might want to use serialisation.
+
+45
+00:03:05,000 --> 00:03:06,000
+Interesting if.
+
+46
+00:03:06,000 --> 00:03:11,000
+Yes, let's run how the resolution works for this lesson.
+
+47
+00:03:11,000 --> 00:03:13,000
+I prepared examples that I'm going to share with you today.
+
+48
+00:03:14,000 --> 00:03:15,000
+Let's jump to Eclipse.
+
+49
+00:03:16,000 --> 00:03:23,000
+Imagine that we have class employee that is some class from our application and this class has next
+
+50
+00:03:23,000 --> 00:03:27,000
+properties, idea, name and list of properties of map type.
+
+51
+00:03:28,000 --> 00:03:34,000
+This class also has getters and setters and imagines that at some point in our program we want to serialize
+
+52
+00:03:34,000 --> 00:03:35,000
+this object.
+
+53
+00:03:35,000 --> 00:03:41,000
+The first thing we have to do is to mark specific type with serializable interface.
+
+54
+00:03:41,000 --> 00:03:47,000
+This is important because without implementing this interface, you will get an exception during the
+
+55
+00:03:47,000 --> 00:03:51,000
+serialization to be more specific, not serializable exception.
+
+56
+00:03:51,000 --> 00:03:57,000
+Let's review the source code of this interface and you can see that this interface declares no mascot's.
+
+57
+00:03:58,000 --> 00:04:00,000
+This is a marker interface.
+
+58
+00:04:00,000 --> 00:04:07,000
+It is a rule in Java that enables the ability of a class it should implements this interface.
+
+59
+00:04:07,000 --> 00:04:10,000
+OK, now let's get back to our file.
+
+60
+00:04:11,000 --> 00:04:14,000
+Now we have employee time that is ready to be centralized.
+
+61
+00:04:15,000 --> 00:04:16,000
+Let's open our demo file.
+
+62
+00:04:17,000 --> 00:04:19,000
+I create object of type employee.
+
+63
+00:04:19,000 --> 00:04:23,000
+I satija name and map with properties.
+
+64
+00:04:23,000 --> 00:04:27,000
+Our A map includes salary and the city great.
+
+65
+00:04:27,000 --> 00:04:29,000
+The Serialize object.
+
+66
+00:04:29,000 --> 00:04:35,000
+I created a separate matter that is called centralized simply lets you use a source code of that massive.
+
+67
+00:04:35,000 --> 00:04:38,000
+I want to declare object outputs three type.
+
+68
+00:04:38,000 --> 00:04:41,000
+It can be created on the basis of output stream.
+
+69
+00:04:42,000 --> 00:04:48,000
+So I create object output stream and POS but array output stream into it.
+
+70
+00:04:48,000 --> 00:04:56,000
+Pay attention here instead of battery output stream, you can specify any other type that extends output
+
+71
+00:04:56,000 --> 00:04:56,000
+stream.
+
+72
+00:04:57,000 --> 00:05:04,000
+I declare all streams in Try with their sources blog inside the blog, I called MassArt right object
+
+73
+00:05:04,000 --> 00:05:12,000
+and pass the reference to my employee object that from this Massett I return by the output stream because
+
+74
+00:05:12,000 --> 00:05:14,000
+I want to source in reference to this object.
+
+75
+00:05:15,000 --> 00:05:21,000
+When times come, I will use this battery output stream object to decentralize my employee object.
+
+76
+00:05:21,000 --> 00:05:22,000
+That's it.
+
+77
+00:05:22,000 --> 00:05:27,000
+I have just generalized and play object how I can decentralize it.
+
+78
+00:05:28,000 --> 00:05:31,000
+Let's review the source code of another method decentralized.
+
+79
+00:05:31,000 --> 00:05:38,000
+Simply, I posta this massive battery output stream that is a stream where my employee object was written
+
+80
+00:05:38,000 --> 00:05:40,000
+as a sequence of bytes.
+
+81
+00:05:40,000 --> 00:05:47,000
+In this method I create object input stream and pass to it by three input stream object that is created
+
+82
+00:05:47,000 --> 00:05:50,000
+on the basis of my battery output stream.
+
+83
+00:05:51,000 --> 00:05:58,000
+In simple words, I redirected my output stream to input stream and now I want to read it.
+
+84
+00:05:59,000 --> 00:06:02,000
+Other sources are declared in other sources.
+
+85
+00:06:02,000 --> 00:06:03,000
+Block one.
+
+86
+00:06:03,000 --> 00:06:06,000
+All objects are created equal object.
+
+87
+00:06:06,000 --> 00:06:11,000
+Masset pay attention that this mass returns object of type object.
+
+88
+00:06:12,000 --> 00:06:19,000
+In case you want to have specific type, you have to cost this object to your time and I return employee
+
+89
+00:06:19,000 --> 00:06:22,000
+object from this massive in our main Macit.
+
+90
+00:06:22,000 --> 00:06:26,000
+I want to bring the employee that we got after the serialization.
+
+91
+00:06:27,000 --> 00:06:30,000
+Let me run the program to show you and transload.
+
+92
+00:06:31,000 --> 00:06:37,000
+My program created an object after that, the program centralized template and after that the program
+
+93
+00:06:37,000 --> 00:06:44,000
+decentralized it and printed object to console and you can see that it is an absolute copy of our original
+
+94
+00:06:44,000 --> 00:06:45,000
+employee.
+
+95
+00:06:45,000 --> 00:06:49,000
+Can you understand now what centralization and decentralization is?
+
+96
+00:06:49,000 --> 00:06:50,000
+Great.
+
+97
+00:06:50,000 --> 00:06:54,000
+Let me add a few more details to serialisation and this realization.
+
+98
+00:06:54,000 --> 00:06:56,000
+Let's go one by one.
+
+99
+00:06:56,000 --> 00:07:02,000
+First of all, you saw that my employee class has specific properties, serial version Yagi.
+
+100
+00:07:02,000 --> 00:07:10,000
+What does this variable for serial version UIGEA is a constant that uniquely in the device, a version
+
+101
+00:07:10,000 --> 00:07:14,000
+of a serializable class universalization process.
+
+102
+00:07:14,000 --> 00:07:18,000
+Java virtual machine verifies this constant why?
+
+103
+00:07:18,000 --> 00:07:26,000
+Imagine that we have original version of an employee class visualized the object and on the other machine
+
+104
+00:07:26,000 --> 00:07:29,000
+where our program is running or even on our machine.
+
+105
+00:07:29,000 --> 00:07:35,000
+But after user updated version of our application, imagine that there is an updated version of employee
+
+106
+00:07:35,000 --> 00:07:42,000
+class, for example, instead of the map with properties, we have separate properties for salary and
+
+107
+00:07:42,000 --> 00:07:45,000
+C.G. and there is no more property of type map anymore.
+
+108
+00:07:45,000 --> 00:07:52,000
+That means that error will happen during institutionalization and our sequence of byte won't be able
+
+109
+00:07:52,000 --> 00:07:59,000
+to be mapped against the current employee type and to distinguish versions of classes that are serialized.
+
+110
+00:07:59,000 --> 00:08:04,000
+This constant exists sometimes, developer said default serial version.
+
+111
+00:08:04,000 --> 00:08:10,000
+Yazji This is equal to one and that's it known that the serial version is optional.
+
+112
+00:08:11,000 --> 00:08:15,000
+You can just ignore this eclipse will show you a warning, but nothing about that.
+
+113
+00:08:16,000 --> 00:08:19,000
+Let's talk about what a transient keyword is.
+
+114
+00:08:19,000 --> 00:08:21,000
+It is better to understand this.
+
+115
+00:08:21,000 --> 00:08:21,000
+An example.
+
+116
+00:08:22,000 --> 00:08:28,000
+Let me add a transient keyword in the property and now let me run my program one more time.
+
+117
+00:08:28,000 --> 00:08:30,000
+Look at the console output.
+
+118
+00:08:30,000 --> 00:08:33,000
+Can its users name property is now.
+
+119
+00:08:33,000 --> 00:08:34,000
+Why?
+
+120
+00:08:34,000 --> 00:08:39,000
+Because Transend keyword tells to ignore this property during the serialization.
+
+121
+00:08:39,000 --> 00:08:43,000
+The string value of name is just not stored to the output stream.
+
+122
+00:08:44,000 --> 00:08:46,000
+Let's get back to inplay class.
+
+123
+00:08:46,000 --> 00:08:48,000
+I will remove transient keywords.
+
+124
+00:08:49,000 --> 00:08:52,000
+I want you to pay attention to two matters here, right?
+
+125
+00:08:52,000 --> 00:08:54,000
+Object and object.
+
+126
+00:08:54,000 --> 00:09:01,000
+Especially pay attention to the access modifiers, return type of data and potential exceptions that
+
+127
+00:09:01,000 --> 00:09:01,000
+can be thrown.
+
+128
+00:09:02,000 --> 00:09:07,000
+This is just a convention and this is something what we have just to remember, in case you want to
+
+129
+00:09:07,000 --> 00:09:13,000
+customize your object before serialization or after decimalization, you can declare these methods in
+
+130
+00:09:13,000 --> 00:09:16,000
+your type and perform anything you need.
+
+131
+00:09:16,000 --> 00:09:22,000
+For example, I have can so random text just to prove you that these methods are invoked.
+
+132
+00:09:23,000 --> 00:09:29,000
+You can always use default, write, object and default to object to process your serialization further.
+
+133
+00:09:29,000 --> 00:09:33,000
+In this methods, you can handle initialization of transient fields.
+
+134
+00:09:33,000 --> 00:09:36,000
+For example, Hobbs's makes things clearer.
+
+135
+00:09:36,000 --> 00:09:38,000
+Let's move on now.
+
+136
+00:09:38,000 --> 00:09:44,000
+Imagine the case that you want to serialize object and you want explicitly tell that process of civilization
+
+137
+00:09:44,000 --> 00:09:45,000
+should be customized.
+
+138
+00:09:46,000 --> 00:09:52,000
+For example, each user has a password or any other sensitive information and you want to encrypt this
+
+139
+00:09:52,000 --> 00:09:56,000
+information before serialization and decrypt after serialization.
+
+140
+00:09:57,000 --> 00:10:04,000
+For the sake of them, I create one more type called user attention, it implements externalizes.
+
+141
+00:10:04,000 --> 00:10:10,000
+All this time has only two fields, Zaya nickname and password.
+
+142
+00:10:11,000 --> 00:10:14,000
+You can see two constructors, getters and setters.
+
+143
+00:10:14,000 --> 00:10:20,000
+And the most interesting part in case you implement externalise all you have to implement, right?
+
+144
+00:10:20,000 --> 00:10:22,000
+External and with external mascot's.
+
+145
+00:10:23,000 --> 00:10:28,000
+It is similar to the way we view it with the serializable type employee and private marcedes.
+
+146
+00:10:29,000 --> 00:10:35,000
+This is more object oriented way to say that this type contains custom logic for serialisation and decentralization.
+
+147
+00:10:36,000 --> 00:10:37,000
+We would open this interface.
+
+148
+00:10:37,000 --> 00:10:44,000
+We would notice that it extends serializable in this messenger as a serialisation and right to the output
+
+149
+00:10:44,000 --> 00:10:46,000
+nickname and custom passwords.
+
+150
+00:10:47,000 --> 00:10:49,000
+We can encode password here, for example.
+
+151
+00:10:50,000 --> 00:10:54,000
+And in the read External Masset, I should read properties one by one.
+
+152
+00:10:54,000 --> 00:10:57,000
+You have to read properties in the same sequence.
+
+153
+00:10:57,000 --> 00:11:02,000
+We wrote them here and you can see that I initialize state of the current object.
+
+154
+00:11:03,000 --> 00:11:09,000
+Let me open our demo program to test utilization and decentralization and create user object first.
+
+155
+00:11:10,000 --> 00:11:16,000
+And after that I call similar methods that we saw during the serialization example that tensions that
+
+156
+00:11:16,000 --> 00:11:18,000
+I created user with this specific password.
+
+157
+00:11:19,000 --> 00:11:25,000
+Let me run the program now in console output, you can see that password is different.
+
+158
+00:11:25,000 --> 00:11:30,000
+That is because we implemented custom logic of civilization and serialization.
+
+159
+00:11:30,000 --> 00:11:31,000
+Does it make sense?
+
+160
+00:11:32,000 --> 00:11:33,000
+Awesome.
+
+161
+00:11:34,000 --> 00:11:38,000
+Now, when you completely learn serialisation, let me talk about a different topic.
+
+162
+00:11:38,000 --> 00:11:40,000
+Let's discuss cloning now.
+
+163
+00:11:41,000 --> 00:11:45,000
+Sometimes in a program you might want to create exact copy of the same object.
+
+164
+00:11:45,000 --> 00:11:52,000
+For example, you want to do some modifications in user object, but you also need to store that reference
+
+165
+00:11:52,000 --> 00:11:53,000
+to the original object.
+
+166
+00:11:53,000 --> 00:12:00,000
+That is helpful in some specific cases when you need to keep both data objects original and updated
+
+167
+00:12:00,000 --> 00:12:04,000
+one and pass them to the front end to compare them together.
+
+168
+00:12:05,000 --> 00:12:08,000
+Each Java object has access to clone masses.
+
+169
+00:12:08,000 --> 00:12:11,000
+Let me open the source code of object class.
+
+170
+00:12:11,000 --> 00:12:13,000
+You can find clone method here.
+
+171
+00:12:14,000 --> 00:12:20,000
+As you can see, this is a native Macit and we can explore its original source code right now.
+
+172
+00:12:20,000 --> 00:12:24,000
+But what we can see is that the massive has protected access modifier.
+
+173
+00:12:25,000 --> 00:12:26,000
+What does it mean?
+
+174
+00:12:26,000 --> 00:12:33,000
+That mean we can't call clone Masset on each object by default, but we have access to this.
+
+175
+00:12:33,000 --> 00:12:35,000
+Protect MassArt inside the class.
+
+176
+00:12:36,000 --> 00:12:37,000
+Let me show you this.
+
+177
+00:12:37,000 --> 00:12:41,000
+All examples that are related to cloning will be stored in cloning package.
+
+178
+00:12:42,000 --> 00:12:45,000
+Let me open this cloning demo file here.
+
+179
+00:12:45,000 --> 00:12:48,000
+You can see that I created the object of a user type.
+
+180
+00:12:48,000 --> 00:12:53,000
+And when I call clone MassArt on this object, I get a completion error.
+
+181
+00:12:53,000 --> 00:13:00,000
+That is because Clone Massett has a protected access modifier and available inside the user type in
+
+182
+00:13:00,000 --> 00:13:01,000
+this class.
+
+183
+00:13:01,000 --> 00:13:07,000
+Java compiler just can see it to make it available outside of the class.
+
+184
+00:13:07,000 --> 00:13:14,000
+We have to override this method inside the type and increase the visibility by changing the access modifier
+
+185
+00:13:14,000 --> 00:13:16,000
+from protected to public.
+
+186
+00:13:17,000 --> 00:13:19,000
+For example, here is an all the time.
+
+187
+00:13:19,000 --> 00:13:24,000
+It contains fields, constructors, getters and setters and clone MassArt.
+
+188
+00:13:24,000 --> 00:13:30,000
+Here you can see that I override clone Masset and make it public inside the method.
+
+189
+00:13:30,000 --> 00:13:36,000
+I just invoke original clone method from the object class you Mycenae that I implemented clone MassArt.
+
+190
+00:13:36,000 --> 00:13:40,000
+Let's check how it works inside the main message.
+
+191
+00:13:40,000 --> 00:13:41,000
+I create a list of products first.
+
+192
+00:13:42,000 --> 00:13:44,000
+Now I can create an object of all the time.
+
+193
+00:13:45,000 --> 00:13:52,000
+I pass some random creditcard no list of products that are associated with this or the end user i.e.
+
+194
+00:13:52,000 --> 00:13:55,000
+who made this so that this is my original order.
+
+195
+00:13:55,000 --> 00:13:58,000
+I printed the console in the next line.
+
+196
+00:13:58,000 --> 00:14:02,000
+I want to clone my original or the object pad tensions.
+
+197
+00:14:02,000 --> 00:14:10,000
+That clone MassArt maestro clone not supported exception when one type that is cloned doesn't implement
+
+198
+00:14:10,000 --> 00:14:12,000
+Coonamble interface.
+
+199
+00:14:12,000 --> 00:14:15,000
+Let me open the source code of all the type one more time.
+
+200
+00:14:16,000 --> 00:14:20,000
+You can see that my order type implements cleanable interface.
+
+201
+00:14:20,000 --> 00:14:21,000
+Let's open this interface.
+
+202
+00:14:22,000 --> 00:14:29,000
+You can see that this is also an interface and Java verifies during the clone and sometimes it is going
+
+203
+00:14:29,000 --> 00:14:29,000
+to be cloned.
+
+204
+00:14:30,000 --> 00:14:32,000
+Implements Cleanable interface.
+
+205
+00:14:33,000 --> 00:14:40,000
+Take this as a permission to all object of this type to be cloned and in case this interface is implemented
+
+206
+00:14:40,000 --> 00:14:45,000
+in the time Java believes you that this permission has been granted, is that clear?
+
+207
+00:14:46,000 --> 00:14:47,000
+Awesome.
+
+208
+00:14:47,000 --> 00:14:49,000
+Let's get back to our demo file.
+
+209
+00:14:49,000 --> 00:14:52,000
+When I cloned object, I printed tokens.
+
+210
+00:14:52,000 --> 00:14:56,000
+So let's run this program in console output.
+
+211
+00:14:56,000 --> 00:15:01,000
+We can compare these two orders, but believe me, they are the same.
+
+212
+00:15:01,000 --> 00:15:03,000
+But they're interesting things to come.
+
+213
+00:15:04,000 --> 00:15:11,000
+What if in the cloned object I will modify state, for example, I will clear all products from the
+
+214
+00:15:11,000 --> 00:15:16,000
+cloned order and get all products and Cochlear Massud on the list.
+
+215
+00:15:17,000 --> 00:15:23,000
+After that I print original order and you can see that list of products is also clean here.
+
+216
+00:15:24,000 --> 00:15:25,000
+How that can be.
+
+217
+00:15:26,000 --> 00:15:31,000
+This may seem to be a weird thing, but this is the way how clone Masset works by default.
+
+218
+00:15:31,000 --> 00:15:38,000
+This is called Shallow Clonan, you shallow clonan only references are copied.
+
+219
+00:15:38,000 --> 00:15:44,000
+Shallow clone in the works just fine for primitive types because they are already stores the value in
+
+220
+00:15:44,000 --> 00:15:53,000
+themselves with reference types of data only references are cloned during shallow cloning, but objects
+
+221
+00:15:53,000 --> 00:15:56,000
+that stand behind those references are not cloned.
+
+222
+00:15:57,000 --> 00:16:04,000
+Geep cloning is focused on the cloning of the whole object's graph, including properties of reference
+
+223
+00:16:04,000 --> 00:16:08,000
+types inside the object and properties of reference types inside those objects.
+
+224
+00:16:09,000 --> 00:16:10,000
+Can you understand this?
+
+225
+00:16:11,000 --> 00:16:11,000
+Awesome.
+
+226
+00:16:12,000 --> 00:16:17,000
+So what we have to do, we have to override clone Masset to make it also clone objects.
+
+227
+00:16:17,000 --> 00:16:19,000
+That stands behind the references.
+
+228
+00:16:20,000 --> 00:16:25,000
+For the sake of the Dharma, I created one more order type that supports the cloning.
+
+229
+00:16:25,000 --> 00:16:28,000
+Let's open the step and explore its clone method.
+
+230
+00:16:28,000 --> 00:16:33,000
+At the beginning, I called the whole object and after that I put all.
+
+231
+00:16:33,000 --> 00:16:39,000
+Only on mutable objects in this particular time, I have only one mutable property.
+
+232
+00:16:39,000 --> 00:16:41,000
+This is a list of products.
+
+233
+00:16:41,000 --> 00:16:43,000
+Spring type is immutable.
+
+234
+00:16:43,000 --> 00:16:46,000
+It will be impossible to change its state after creation.
+
+235
+00:16:46,000 --> 00:16:49,000
+It will be possible only to Saturnus three.
+
+236
+00:16:49,000 --> 00:16:53,000
+That's why I am not worrying about it also.
+
+237
+00:16:53,000 --> 00:16:56,000
+And don't worry about in the field since this is a primitive time.
+
+238
+00:16:56,000 --> 00:17:02,000
+But for products list, I did a copy and I said this copy to my client object.
+
+239
+00:17:02,000 --> 00:17:06,000
+Now let's check how deep coding works for this type.
+
+240
+00:17:07,000 --> 00:17:11,000
+I initialize product list that was cleared one more time after that.
+
+241
+00:17:11,000 --> 00:17:14,000
+A great object of our new type zann.
+
+242
+00:17:14,000 --> 00:17:21,000
+I clone this object and similar to the previous example, actually as a list of products in my client
+
+243
+00:17:21,000 --> 00:17:28,000
+object and print two objects to consult, I expect that products placed in original order won't be empty.
+
+244
+00:17:29,000 --> 00:17:35,000
+In Arkansas, we can see that we achieved our goal and product list is not empty in my original order
+
+245
+00:17:35,000 --> 00:17:37,000
+and it is empty in cloned order.
+
+246
+00:17:38,000 --> 00:17:38,000
+Great.
+
+247
+00:17:39,000 --> 00:17:41,000
+Now you know how to do Geep Clonan.
+
+248
+00:17:41,000 --> 00:17:44,000
+Feel free to let me know in case you have any questions.
+
+249
+00:17:45,000 --> 00:17:47,000
+None how serialization works.
+
+250
+00:17:47,000 --> 00:17:53,000
+You might think that serialize and visualize an object doesn't sound like a better year in case you
+
+251
+00:17:53,000 --> 00:18:00,000
+want to clone an object because implement clone MassArt that would properly clone old graph of objects.
+
+252
+00:18:00,000 --> 00:18:02,000
+It can be very complicated task.
+
+253
+00:18:02,000 --> 00:18:07,000
+Sometimes you may consider serialisation mechanism to make a clone very fast.
+
+254
+00:18:08,000 --> 00:18:10,000
+That's all what I wanted to share with you today.
+
+255
+00:18:10,000 --> 00:18:12,000
+Let's recap what we have learned today.
+
+256
+00:18:13,000 --> 00:18:19,000
+In this lesson we learned what serialization is rereviewed serializable Marka interface.
+
+257
+00:18:19,000 --> 00:18:23,000
+Now you know how centralized and decentralized your objects.
+
+258
+00:18:23,000 --> 00:18:27,000
+You also learned what externalise interface is.
+
+259
+00:18:27,000 --> 00:18:30,000
+After that, we learned how Clonan Java works.
+
+260
+00:18:31,000 --> 00:18:33,000
+Now, you know, cleanable interface.
+
+261
+00:18:33,000 --> 00:18:37,000
+Today we learned what is the difference between deep and shallow clonan.
+
+262
+00:18:37,000 --> 00:18:41,000
+Also, we had a lot of practice that will help you to complete your homework.
+
+263
+00:18:42,000 --> 00:18:43,000
+Let's review your homework now.
+
+264
+00:18:44,000 --> 00:18:48,000
+After this topic, you are going to have only one simple coding exercise.
+
+265
+00:18:48,000 --> 00:18:54,000
+I promise you, we keep improving our online shop, taking into account all the time, has a list of
+
+266
+00:18:54,000 --> 00:18:55,000
+products inside.
+
+267
+00:18:55,000 --> 00:18:59,000
+It will be not very convenient to store it in comma separated files.
+
+268
+00:18:59,000 --> 00:19:06,000
+In scope of this task, you have to serialize all orders to the file and one program will be started
+
+269
+00:19:06,000 --> 00:19:06,000
+again.
+
+270
+00:19:06,000 --> 00:19:10,000
+You have to decentralize or this again home.
+
+271
+00:19:10,000 --> 00:19:11,000
+This is clear.
+
+272
+00:19:11,000 --> 00:19:13,000
+That's all what I wanted to share with you today.
+
+273
+00:19:14,000 --> 00:19:15,000
+Thanks a lot for your attention.
+
+274
+00:19:15,000 --> 00:19:18,000
+Have a great day here in the next lesson.
+

25 - Input and Output Streams in Java/005 Source-code-examples-from-the-lesson-Cloning.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/cloning

25 - Input and Output Streams in Java/005 Source-code-examples-from-the-lesson-Serialization.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/io/serialization

25 - Input and Output Streams in Java/006 Quiz InputOutput Streams - Check yourself.html

@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>Quiz InputOutput Streams - Check yourself</title>
+
+        <style>
+            * {
+                box-sizing: border-box;
+                margin: 0;
+                padding: 0;
+            }
+            body {
+                font-family: var(--font-stack-text);
+                font-weight: 400;
+                line-height: 1.4;
+                font-size: 1.6rem;
+                color: #2d2f31;
+            }
+            .container {
+                position: relative;
+                height: 100%;
+                overflow-y: auto;
+            }
+            .content {
+                padding: 3.2rem 4.8rem;
+                word-break: break-word;
+                max-width: 69.6rem;
+                margin: 0 auto;
+            }
+            .heading {
+                margin-bottom: 24px;
+                font-family: -apple-system, BlinkMacSystemFont, Roboto, "Segoe UI", Helvetica, Arial, sans-serif,
+                    "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+                font-weight: 700;
+                line-height: 1.2;
+                letter-spacing: 0;
+                font-size: 32px;
+                max-width: 36em;
+            }
+            .article-asset-container {
+                padding: 2.4rem;
+            }
+            .article-asset-container p {
+                font-size: 19px;
+            }
+            code {
+                background-color: #fff;
+                border: 1px solid #d1d7dc;
+                color: #b4690e;
+                font-size: 80%;
+                padding: 0.2rem 0.4rem;
+                font-family: sfmono-regular, Consolas, liberation mono, Menlo, Courier, monospace;
+            }
+            p {
+                font-weight: 400;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <div class="content">
+                <div class="heading">Quiz InputOutput Streams - Check yourself</div>
+                <div class="article-asset-container"><p><strong>Quiz Link: </strong><a href="https://forms.gle/jpwGZB1p7raYHuZ69" rel="noopener noreferrer" target="_blank"><strong>https://forms.gle/jpwGZB1p7raYHuZ69</strong></a></p><p>The quiz doesn’t require you to log in or submit any personal information. Your data privacy is my priority.</p><p>The Quiz covers content from the following lessons:</p><ul><li><p>Input and Output Streams in Java</p></li><li><p>Serialization and Object Cloning</p></li></ul><p><br></p><p><strong>Quiz Instructions:</strong></p><p>This quiz is designed to help you check your understanding of the content from the previous lessons. All questions are based only on material covered in the lessons you've already watched, so there’s no need to worry about unfamiliar topics.</p><ul><li><p>Each question has one correct answer. Select the best answer and click "Submit" when you're ready.</p></li><li><p>After submitting, you'll see your score. For each question, you earn 1 point.</p></li><li><p>Click "View Results" to see the explanations for each correct answer. Reviewing these explanations can help reinforce your understanding.</p></li><li><p>If you score below 70%, I recommend revisiting the previous lessons. However, if the explanations make sense and you’re confident in your understanding, feel free to move on.</p></li><li><p>If any explanations are unclear, please don’t hesitate to post questions in the Q&amp;A section—I’m here to help!</p></li></ul></div>
+            </div>
+        </div>
+    </body>
+</html>

25 - Input and Output Streams in Java/external-links.txt

@@ -0,0 +1,24 @@
+
+001 Source-code-examples-from-lesson
+https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/io
+
+001 Homework
+https://docs.google.com/document/d/12mpGjQti9SwYrCS-0RU-WNYtEQCKSFwjgiCS8iKDnTw/edit?usp=sharing
+
+001 Solution-of-homework
+https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/io/hw
+
+001 Solution-of-Homework-Online-store-with-data-storage
+https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/finaltask/storage
+
+005 Source-code-examples-from-the-lesson-Serialization
+https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/io/serialization
+
+005 Source-code-examples-from-the-lesson-Cloning
+https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/cloning
+
+005 Homework
+https://docs.google.com/document/d/1gAwAtOMhaQOCIhc_QM8XreCn_QThfOxAKmw-ufTCk7Y/edit?usp=sharing
+
+005 Homework-solution
+https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/finaltask/storage/impl/DefaultUserStoringService.java

26 - ===== IO in Java Interview Preparation =====/001 Part 1 Java IO Interview - Questions and Answers.html

@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>Part 1 Java IO Interview - Questions and Answers</title>
+
+        <style>
+            * {
+                box-sizing: border-box;
+                margin: 0;
+                padding: 0;
+            }
+            body {
+                font-family: var(--font-stack-text);
+                font-weight: 400;
+                line-height: 1.4;
+                font-size: 1.6rem;
+                color: #2d2f31;
+            }
+            .container {
+                position: relative;
+                height: 100%;
+                overflow-y: auto;
+            }
+            .content {
+                padding: 3.2rem 4.8rem;
+                word-break: break-word;
+                max-width: 69.6rem;
+                margin: 0 auto;
+            }
+            .heading {
+                margin-bottom: 24px;
+                font-family: -apple-system, BlinkMacSystemFont, Roboto, "Segoe UI", Helvetica, Arial, sans-serif,
+                    "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+                font-weight: 700;
+                line-height: 1.2;
+                letter-spacing: 0;
+                font-size: 32px;
+                max-width: 36em;
+            }
+            .article-asset-container {
+                padding: 2.4rem;
+            }
+            .article-asset-container p {
+                font-size: 19px;
+            }
+            code {
+                background-color: #fff;
+                border: 1px solid #d1d7dc;
+                color: #b4690e;
+                font-size: 80%;
+                padding: 0.2rem 0.4rem;
+                font-family: sfmono-regular, Consolas, liberation mono, Menlo, Courier, monospace;
+            }
+            p {
+                font-weight: 400;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <div class="content">
+                <div class="heading">Part 1 Java IO Interview - Questions and Answers</div>
+                <div class="article-asset-container"><ul><li><p><strong>WHAT TYPES OF I/O STREAMS ARE THERE?</strong></p></li></ul><p><br></p><p>I/O streams are used to transfer data to file streams, to the console, or to network connections. There are two kinds of I/O streams: byte and character.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE DIFFERENCE BETWEEN I/O AND NIO?</strong></p></li></ul><p><br></p><p>I / O (input / output, input-output) - the interaction between the information processor and its provider and / or recipient. Input is the signal or data received by the handler, and output is the signal or data sent by (or from) it.</p><p><br></p><p>NIO (/*in the context of Java*/ Non-blocking I/O, New I/O) is a collection of application programming interfaces for the Java language designed to implement high-performance I/O operations.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT FEATURES OF NIO DO YOU KNOW?</strong></p></li></ul><p><br></p><p>Key features of NIO:</p><ul><li><p>Channels and Selectors: NIO supports various types of channels. A pipe is an abstraction of lower-level file system objects (such as memory-mapped files and file locks) that allow data to be transferred at a faster rate. Channels are non-blocking, and therefore Java provides other tools such as a selector, which allows you to choose a ready channel for data transfer, and a socket, which is a tool for blocking.</p></li><li><p>Buffers: Java 7 introduced buffering for all primitive wrapper classes (except Boolean). An abstract Buffer class has appeared, which provides operations such as clear, flip, mark, etc. Its subclasses provide methods for getting and setting data.</p></li><li><p>Encodings: Java 7 introduced encodings (java.nio.charset), encoders and decoders for displaying Unicode bytes and characters.</p></li></ul><p><br></p><p><br></p><p><br></p><ul><li><p><strong>NAME THE MAIN CLASSES OF I/O STREAMS.</strong></p></li></ul><p><br></p><p>Byte streams: java.io.InputStream, java.io.OutputStream;</p><p>Character streams: java.io.Reader, java.io.Writer;</p><p><br></p><p><br></p><p><br></p><ul><li><p><strong>HOW ARE OUTPUTSTREAM, INPUTSTREAM, WRITER AND READER DIFFERENT?</strong></p></li></ul><p><br></p><p>The OutputStream class is an abstract class that defines streaming byte output. This category contains classes that define whether your data is going into a byte array (but not directly to a String; you are supposed to be able to create it from a byte array), to a file, or to a pipe.</p><p><br></p><p>The base class InputStream represents classes that receive data from various sources:</p><ul><li><p>byte array</p></li><li><p>string</p></li><li><p>file</p></li><li><p>channel (pipe): data is placed at one end and retrieved from the other</p></li><li><p>a sequence of different streams that can be combined into a single stream</p></li><li><p>other sources (for example, internet connection)</p></li></ul><p><br></p><p>Character streams have two main abstract classes, Reader and Writer, that manage streams of Unicode characters. The Reader class is an abstract class that defines character stream input. The Writer class is an abstract class that defines character stream output. In case of errors, all methods of the class throw an IOException.</p><p><br></p><p><br></p><ul><li><p><strong>WHICH SUBCLASSES OF THE INPUTSTREAM BASE CLASS DO YOU KNOW WHAT THEY ARE FOR?</strong></p></li></ul><p><br></p><p>Popular Subclasses of the base InputStream class:</p><ul><li><p>StringBufferInputStream - turns a string (String) into an InputStream.</p></li><li><p>SequenceInputStream - merges two or more InputStreams into a single stream.</p></li><li><p>PushbackInputStream - an input stream that supports a one-byte return to the input stream.</p></li><li><p>PipedInputStream - implements the concept of an input channel.</p></li><li><p>ObjectInputStream - input stream for objects.</p></li><li><p>InputStream is an abstract class that describes an input stream.</p></li><li><p>FilterInputStream is an abstract class that provides an interface for add-on classes that add useful properties to existing streams.</p></li><li><p>FileInputStream - for reading information from a file.</p></li><li><p>DataInputStream - An input stream that includes methods for reading standard Java data types.</p></li><li><p>ByteArrayInputStream - allows you to use an in-memory buffer (byte array) as the data source for the input stream.</p></li><li><p>BufferedInputStream - buffered input stream.</p></li></ul><p><br></p><p><br></p><p><br></p><ul><li><p><strong>WHAT DO YOU KNOW ABOUT RANDOMACCESSFILE?</strong></p></li></ul><p><br></p><p>RandomAccessFile is a class that inherits directly from Object and does not inherit from the I/O base classes above. Designed to work with files, supporting random access to their contents.</p><p><br></p><p>Working with the RandomAccessFile class is similar to using the DataInputStream and DataOutputStream streams combined in the same class (they implement the same DataInput and DataOutput interfaces). In addition, the seek() method allows you to move to a specific position and change the value stored there.</p><p><br></p><p>When using RandomAccessFile, you need to know the structure of the file. The RandomAccessFile class contains methods for reading and writing UTF-8 primitives and strings.</p><p><br></p><p><br></p><p><br></p><ul><li><p><strong>WHAT FILE ACCESS MODES DO RANDOMACCESSFILE HAVE?</strong></p></li></ul><p><br></p><p>RandomAccessFile can be opened in read ("r") or read/write ("rw") mode. There is also an "rws" mode where the file is opened for read/write operations and every change to the file's data is immediately written to the physical device.</p><p><br></p><p><br></p><ul><li><p><strong>WHICH SUBCLASSES OF THE BASE CLASS OUTPUTSTREAM DO YOU KNOW WHAT THEY ARE FOR?</strong></p></li></ul><p><br></p><p>The OutputStream class is an abstract class that defines streaming byte output.</p><p>This category contains classes that define whether your data is going to a byte array (but not directly to a String; you are supposed to be able to create it from a byte array), to a file, or to a pipe.</p><p><br></p><p>Subclasses of the base class OutputStream:</p><ul><li><p>PipedOutputStream - implements the concept of an output channel.</p></li><li><p>ObjectOutputStream - output stream for objects</p></li><li><p>FilterOutputStream is an abstract class that provides an interface for add-on classes that add useful properties to existing streams.</p></li><li><p>FileOutputStream - send data to a file on disk. Implementation of the OutputStream class.</p></li><li><p>DataOutputStream - An output stream that includes methods for writing standard Java data types.</p></li><li><p>ByteArrayOutputStream - Creates an in-memory buffer. All data sent to this stream is placed in the created buffer.</p></li><li><p>BufferedOutputStream - buffered output stream.</p></li></ul><p><br></p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS PUSHBACKINPUTSTREAM USED FOR?</strong></p></li></ul><p><br></p><p>A type of buffering that reads a byte and then returns it to the stream. The PushbackInputStream class provides a mechanism to "look" into the input stream and see what will come from there next time without extracting information.</p><p><br></p><p>The class has an additional unread() method.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS SEQUENCEINPUTSTREAM USED FOR?</strong></p></li></ul><p><br></p><p>The SequenceInputStream class allows multiple instances of the InputStream class to be chained together. The constructor takes as an argument either a pair of objects of the InputStream class or the Enumeration interface.</p><p>During operation, the class makes requests to read from the first object of the InputStream class to the end, and then switches to the second. When using the interface, work will continue on all objects of the InputStream class. When the end of each file is reached, the associated stream is closed. Closing a stream created by an object of the SequenceInputStream class closes all open streams.</p><p><br></p><p><br></p><p><br></p><ul><li><p><strong>WHICH SUBCLASS OF THE READER BASE CLASS DO YOU KNOW WHAT THEY ARE FOR?</strong></p></li></ul><p><br></p><p>Subclasses of the Reader base class:</p><ul><li><p>StringReader is an input stream reading from a string.</p></li><li><p>Reader is an abstract class that describes character input.</p></li><li><p>PushbackReader is an input stream that allows characters to be pushed back into the stream.</p></li><li><p>PipedReader - input channel.</p></li><li><p>LineNumberReader - an input stream that counts lines.</p></li><li><p>InputStreamReader - an input stream that translates bytes into characters.</p></li><li><p>FilterReader - filter reader.</p></li><li><p>FileReader is an input stream that reads a file.</p></li><li><p>CharArrayReader - an input stream that reads from a character array.</p></li><li><p>BufferedReader - buffered input character stream.</p></li></ul><p><br></p><p><br></p><p><br></p><ul><li><p><strong>WHICH SUBCLASSES OF THE WRITER BASE CLASS DO YOU KNOW WHAT THEY ARE FOR?</strong></p></li></ul><p><br></p><p>Subclasses of the Writer base class:</p><ul><li><p>Writer - an abstract class that describes character output</p></li><li><p>StringWriter - the output stream writing to the string</p></li><li><p>PrintWriter - output stream including print() and println() methods</p></li><li><p>PipedWriter - the output pipe</p></li><li><p>OutputStreamWriter - output stream that translates bytes into characters</p></li><li><p>FilterWriter - filter writer</p></li><li><p>FileWriter - the output stream that writes to the file</p></li><li><p>CharArrayWriter - the output stream that writes to the character array</p></li><li><p>BufferedWriter - buffered output character stream</p></li></ul><p><br></p></div>
+            </div>
+        </div>
+    </body>
+</html>

26 - ===== IO in Java Interview Preparation =====/002 Part 2 Java IO Interview - Questions and Answers.html

@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>Part 2 Java IO Interview - Questions and Answers</title>
+
+        <style>
+            * {
+                box-sizing: border-box;
+                margin: 0;
+                padding: 0;
+            }
+            body {
+                font-family: var(--font-stack-text);
+                font-weight: 400;
+                line-height: 1.4;
+                font-size: 1.6rem;
+                color: #2d2f31;
+            }
+            .container {
+                position: relative;
+                height: 100%;
+                overflow-y: auto;
+            }
+            .content {
+                padding: 3.2rem 4.8rem;
+                word-break: break-word;
+                max-width: 69.6rem;
+                margin: 0 auto;
+            }
+            .heading {
+                margin-bottom: 24px;
+                font-family: -apple-system, BlinkMacSystemFont, Roboto, "Segoe UI", Helvetica, Arial, sans-serif,
+                    "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+                font-weight: 700;
+                line-height: 1.2;
+                letter-spacing: 0;
+                font-size: 32px;
+                max-width: 36em;
+            }
+            .article-asset-container {
+                padding: 2.4rem;
+            }
+            .article-asset-container p {
+                font-size: 19px;
+            }
+            code {
+                background-color: #fff;
+                border: 1px solid #d1d7dc;
+                color: #b4690e;
+                font-size: 80%;
+                padding: 0.2rem 0.4rem;
+                font-family: sfmono-regular, Consolas, liberation mono, Menlo, Courier, monospace;
+            }
+            p {
+                font-weight: 400;
+            }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <div class="content">
+                <div class="heading">Part 2 Java IO Interview - Questions and Answers</div>
+                <div class="article-asset-container"><ul><li><p><strong>WHAT IS THE ABSOLUTE PATH AND RELATIVE PATH?</strong></p></li></ul><p><br></p><p>An absolute path is a path that points to the same location in the file system, regardless of the current directory. The full path always starts from the root directory.</p><p><br></p><p>A relative path is a path relative to the current working directory.</p><p><br></p><p><br></p><ul><li><p><strong>IN WHAT PACKAGES DO THE I/O CLASSES BE IN?</strong></p></li></ul><p><br></p><p>The standard I/O classes in Java are in the java.io.* package. JDK 7 added a more modern way of working with threads called Java NIO or Java New IO, these classes are in the java.nio.* package. To work with archives, classes from the java.util.* package are used.</p><p><br></p><p><br></p><p><br></p><ul><li><p><strong>WHAT DO YOU KNOW ABOUT I/O WRAPPER CLASSES?</strong></p></li></ul><p>I/O wrapper classes are classes that add useful additional properties to existing streams.</p><p><br></p><p>Class examples: BufferedOutputStream, BufferedInputStrem, BufferedWriter , BufferedReader - buffer the stream and improve performance.</p><p><br></p><p><br></p><p><br></p><ul><li><p><strong>WHICH CLASS ALLOWS READING DATA FROM INPUT BYTESTREAM IN THE FORMAT OF PRIMITIVE DATA TYPES?</strong></p></li></ul><p><br></p><p>To read byte data (not strings), use the DataInputStream class. In this case, you must use the classes from the InputStream group.</p><p><br></p><p>The getBytes() method is provided in the String class to convert a string into an array of bytes suitable for putting into a ByteArrayInputStream. The resulting ByteArrayInputStream is an InputStream suitable for passing the DataInputStream.</p><p><br></p><p>When reading characters byte-by-byte from a formatted DataInputStream using the readByte() method, any value received will be considered valid, so the return value is not applicable to identify the end of the stream. Instead, you can use the available() method, which tells you how many characters are left.</p><p><br></p><p>The DataInputStream class allows you to read primitive data types from a stream through the DataInput interface, which defines methods that convert elementary values ​​to a sequence of bytes. Such streams make it easy to store binary data in a file.</p><p><br></p><p><br></p><ul><li><p><strong>WHICH CLASS-SUPPLIERS ALLOW TO ACCELERATE READ/WRITE BY USE OF THE BUFFER?</strong></p></li></ul><p><br></p><p>For this, classes are used that allow buffering the stream:</p><ul><li><p>java.io.BufferedInputStream - buffered input stream. Constructors: BufferedInputStream(InputStream in), BufferedInputStream(InputStream in, int size).</p></li><li><p>java.io.BufferedOutputStream - buffered output stream. Constructors: BufferedOutputStream(OutputStream out), BufferedOutputStream(OutputStream out, int size).</p></li><li><p>java.io.BufferedReader - buffered input character stream. Constructors: BufferedReader(Reader r), BufferedReader(Reader in, int sz).</p></li><li><p>java.io.BufferedWriter - buffered output character stream. Constructors: BufferedWriter(Writer out), BufferedWriter(Writer out, int sz).</p></li></ul><p><br></p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE DIFFERENCE OF THE PRINTWRITER CLASS FROM PRINTSTREAM?</strong></p></li></ul><p><br></p><p>First of all, the PrintWriter class uses an improved way of working with UNICODE characters and a different output buffering mechanism.</p><p><br></p><p>In the PrintStream class, the output buffer was flushed whenever the print or println method was called. When using the PrintWriter class, you can disable automatically flushing buffers by doing it explicitly with the flush method.</p><p><br></p><p>The PrintWriter class provides two constructors that allow you to work with the output streams of the OutputStream class:</p><ul><li><p>public PrintWriter(OutputStream out); - creates a stream without automatically flushing buffers.</p></li><li><p>public PrintWriter(OutputStream out, boolean autoFlush); - the way buffers are flushed when using the second constructor depends on the value of the autoFlush parameter. If it is true, automatic flushing of buffers is performed, and if it is false, it is not.</p></li></ul><p><br></p><p>The set of implementations of the main print and println methods of the PrintWriter class is similar to the set of implementations of these methods of the PrintStream class.</p><p><br></p><p><br></p><p><br></p><ul><li><p><strong>WHICH CLASS IS INTENDED TO WORK WITH FILE SYSTEM ELEMENTS?</strong></p></li></ul><p><br></p><p>Unlike most I/O classes, the File class does not work with streams, but directly with files. This class allows you to get information about the file: access rights, time and date of creation, directory path. And also to navigate through the hierarchies of subdirectories.</p><p><br></p><p>The java.io.File class can represent the name of a specific file, as well as the names of a group of files found in a directory. If the class represents a directory, then its list() method returns an array of strings with the names of all the files.</p><p><br></p><p>You can use one of the following constructors to create objects of the File class.</p><ul><li><p>File(File dir, String name) - you specify object of class File (the directory where file is located) and file name are specified</p></li><li><p>File(String path) - specify the path to the file without specifying the file name</p></li><li><p>File(String dirPath, Sring name) - specifies the path to the file and the file name</p></li><li><p>File(URI url) - specifies the URI object describing the file</p></li></ul><p><br></p><p><br></p><p><br></p><ul><li><p><strong>WHICH CHARACTER IS THE DIVIDER FOR A PATH IN A FILE SYSTEM?</strong></p></li></ul><p><br></p><p>The delimiter symbol differs for different systems. You can pull it out from the property of the static field File.separator. For Windows it is "\".</p><p><br></p><p><br></p><p><br></p><ul><li><p><strong>WHICH FILE CLASS METHODS DO YOU KNOW?</strong></p></li></ul><p><br></p><p>The File class has a lot of methods, let's list some of them.</p><ul><li><p>getAbsolutePath() - the absolute path of the file, starting from the system root. In Android, the root element is the slash character (/)</p></li><li><p>canRead() - verifies whether the file is available for reading</p></li><li><p>canWrite() - available for writing</p></li><li><p>exists() - file exists or not</p></li><li><p>getName() - returns the file name</p></li><li><p>getParent() - returns the name of the parent directory</p></li><li><p>getPath() - path</p></li><li><p>lastModified() - last modified date</p></li><li><p>isFile() - the object is a file, not a directory</p></li><li><p>isDirectory() - the object is a directory</p></li><li><p>isAbsolute() - returns true if the file has an absolute path</p></li><li><p>renameTo(File newPath) - Renames a file. The parameter specifies the name of the new file name. If the rename was unsuccessful, then false is returned.</p></li><li><p>delete() - deletes a file. You can also delete an empty directory</p></li></ul><p><br></p><p><br></p><ul><li><p><strong>WHAT DO YOU KNOW ABOUT THE FILEFILTER INTERFACE?</strong></p></li></ul><p><br></p><p>The FileFilter interface is used to check if a File object matches a certain condition. This interface contains a single boolean accept(File pathName) method. This method must be overridden and implemented.</p><p><br></p><p><br></p><ul><li><p><strong>WHICH CLASSES ALLOW OBJECTS TO ARCHIVE?</strong></p></li></ul><p><br></p><p>DeflaterOutputStream, InflaterInputStream, ZipInputStream, ZipOutputStream, GZIPInputStream, GZIPOutputStream.</p><p><br></p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS SERIALIZATION?</strong></p></li></ul><p><br></p><p>Serialization is the process of reading or writing an object. It is the process of saving the state of an object and reading that state. To implement serialization, you need to implement an interface - the Serializable marker interface. The reverse operation - translating bytes into an object, is called deserialization.</p><p><br></p><p><br></p><p><br></p><ul><li><p><strong>HOW TO EXCLUDE FIELDS FROM SERIALIZATION?</strong></p></li></ul><p><br></p><p>In order to exclude fields from the serializable stream, it is necessary to mark the field with the transient modifier.</p><p><br></p><p><br></p><ul><li><p><strong>TRANSIENT WHAT DOES IT MEAN?</strong></p></li></ul><p><br></p><p>Class properties marked with the transient modifier are not serialized. Typically, such fields store the intermediate state of the object, which, for example, is easier to calculate than to serialize and then deserialize. Another example of such a field is a reference to an instance of an object that does not require or cannot be serialized.</p><p><br></p><p><br></p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE ROLE OF THE SERIALVERSIONUID FIELD IN SERIALIZATION?</strong></p></li></ul><p><br></p><p>The private static final long serialVersionUID field contains the unique version identifier of the serialized class. It is calculated from the contents of the class - the fields, their declaration order, the methods, their declaration order. Accordingly, with any change in the class, this field will change its value.</p><p><br></p><p>This field is written to the stream when the class is serialized. By the way, this is perhaps the only known case when a static field is serialized.</p><p><br></p><p><br></p><p><br></p><ul><li><p><strong>WHAT CLASSES ALLOW TO CONVERT BYTE STREAMS TO CHARACTER AND BACK?</strong></p></li></ul><p><br></p><p>The OutputStreamWriter is a bridge between the OutputStream class and the Writer class. Characters written to the stream are converted to bytes.</p><p><br></p><p>InputStreamReader - analogue for reading. Using the methods of the Reader class, bytes are read from the InputStream and then converted into characters.</p><p><br></p><p><br></p><p><br></p><ul><li><p><strong>HOW TO CHANGE THE STANDARD SERIALIZATION/DESERIALIZATION BEHAVIOR?</strong></p></li></ul><p><br></p><p>In most cases, we do not define behavior manually, but rely on the standard implementation, and it is very inconvenient to constantly override some serialization methods + constantly monitor the addition of new fields, add them to methods. Well and specially for these purposes - there is Externalizable.</p><p>However, we know that you can change the default behavior of serialization by predefining and placing two methods in your class files:</p><p><br></p><ul><li><p>private void writeObject(ObjectOutputStream out) throws IOException;</p></li><li><p>private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException;</p></li></ul><p><br></p><p>Note that both methods are declared private as this ensures that the methods are not overridden or overloaded. The whole trick is that the virtual machine, when calling the corresponding method, automatically checks if they were declared in the object class. The virtual machine can call the private methods of your class at any time, but other objects cannot. This ensures the integrity of the class and the normal operation of the serialization protocol.</p><p><br></p><p><br></p><ul><li><p><strong>HOW TO CREATE YOUR OWN SERIALIZATION PROTOCOL?</strong></p></li></ul><p><br></p><p>Instead of implementing the Serializable interface, you can implement the Externalizable interface, which contains two methods:</p><p><br></p><ul><li><p>public void writeExternal(ObjectOutput out) throws IOException;</p></li><li><p>public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;</p></li></ul><p><br></p><p>To create your own protocol, you just need to override these two methods. Unlike the other two serialization options, nothing is done automatically here. The protocol is completely in your hands. Although this is the most difficult method, it is also brings you the most controll over serialization process.</p><p><br></p><p><br></p><ul><li><p><strong>WHAT IS THE PROBLEM OF SERIALIZING SINGLETON OBJECTS?</strong></p></li></ul><p><br></p><p>The problem is that after deserialization we will get another object. So serialization makes it possible to create a Singleton again, which is not what we want when we design singleton. Of course, you can forbid serializing Singletons, but this, in fact, is an avoidance of the problem, not a solution to it.</p><p><br></p><p>The solution is the following. The class defines a method with the following signature:</p><p><br></p><ul><li><p>&lt;ANY_ACCESS_MODIFIER&gt; readResolve() throws ObjectStreamException;</p></li></ul><p><br></p><p>The access modifier can be private, protected, and default. The purpose of this method is to return a replacement object instead of the object on which it is called.</p><p><br></p></div>
+            </div>
+        </div>
+    </body>
+</html>

27 - Multithreading/001 Multithreading Overview_en.srt

@@ -0,0 +1,740 @@
+1
+00:00:05,000 --> 00:00:11,000
+Hello, yes, students today will start learning a new topic, Moonface Riden, this is huge topic,
+
+2
+00:00:11,000 --> 00:00:16,000
+and after this course, you will have a lot of knowledge that you can apply in different programming
+
+3
+00:00:16,000 --> 00:00:21,000
+languages to support not just execution, but in scope of this course.
+
+4
+00:00:21,000 --> 00:00:27,000
+I will show you how MultiThreaded works on Java examples and take into account this is the first lesson
+
+5
+00:00:27,000 --> 00:00:32,000
+of new topic, this lesson a little bit more theoretical one to be sure that we have enough high level
+
+6
+00:00:32,000 --> 00:00:37,000
+knowledge and understanding before we'll start sharing, quote, examples in the next lesson.
+
+7
+00:00:37,000 --> 00:00:43,000
+That's why today we'll focus our attention on such questions as what is the process in our computers?
+
+8
+00:00:43,000 --> 00:00:45,000
+What is the threat of execution?
+
+9
+00:00:46,000 --> 00:00:52,000
+What is multithreaded in programming also in this lesson and explain how multiscreen works and what
+
+10
+00:00:52,000 --> 00:00:54,000
+threats and translation means.
+
+11
+00:00:54,000 --> 00:00:59,000
+And the standard answers on these questions will bring us to the point where we can discuss with you
+
+12
+00:00:59,000 --> 00:01:02,000
+why multiscreen is needed and what a benefit, something which is written.
+
+13
+00:01:03,000 --> 00:01:09,000
+And also we'll discuss dark side of multithreaded to understand it, drawbacks and what we should always
+
+14
+00:01:09,000 --> 00:01:12,000
+take into account while working as much as freedom.
+
+15
+00:01:12,000 --> 00:01:17,000
+And the end of the lesson, I will give you an overview of what packages and tools we are going to learn
+
+16
+00:01:17,000 --> 00:01:19,000
+in this course in JDK.
+
+17
+00:01:19,000 --> 00:01:25,000
+Answering all these questions will give you insights on what we are going to learn in this course.
+
+18
+00:01:25,000 --> 00:01:27,000
+I believe we are good with our agenda for today.
+
+19
+00:01:27,000 --> 00:01:34,000
+Let's start and before we even start discussion of multithreaded in the program, let's understand what
+
+20
+00:01:34,000 --> 00:01:36,000
+the process is in computer science.
+
+21
+00:01:36,000 --> 00:01:40,000
+In simple words, process is an instance of a computer program.
+
+22
+00:01:41,000 --> 00:01:42,000
+You opened a glimpse.
+
+23
+00:01:42,000 --> 00:01:45,000
+It's a separate process to run as a Java program.
+
+24
+00:01:46,000 --> 00:01:47,000
+Is that a separate Java process?
+
+25
+00:01:48,000 --> 00:01:53,000
+Computer program is nothing more than a set of instructions for a machine but process.
+
+26
+00:01:54,000 --> 00:01:56,000
+It is an execution of these instructions.
+
+27
+00:01:57,000 --> 00:02:00,000
+A process has a self-contained execution environment.
+
+28
+00:02:00,000 --> 00:02:04,000
+That means that each process has its own memory space.
+
+29
+00:02:05,000 --> 00:02:10,000
+And as I said before, usually processes and programs are considered to be very close terms.
+
+30
+00:02:11,000 --> 00:02:18,000
+But what end user interaction with may be a set of processes that interact with each other doing no
+
+31
+00:02:18,000 --> 00:02:21,000
+such popular Internet browser as Google Chrome?
+
+32
+00:02:21,000 --> 00:02:24,000
+So long to go home and look at the task manager.
+
+33
+00:02:25,000 --> 00:02:28,000
+You will see separate processes for each stop in your browser.
+
+34
+00:02:28,000 --> 00:02:33,000
+But for the end user, Manglehorn perceived like a single application.
+
+35
+00:02:33,000 --> 00:02:40,000
+This is because most operating system support interpersonal communication resources, sap, pipes and
+
+36
+00:02:40,000 --> 00:02:41,000
+sockets.
+
+37
+00:02:41,000 --> 00:02:47,000
+These resources are used to interact between different processes, homes, and this is pretty straightforward.
+
+38
+00:02:48,000 --> 00:02:51,000
+Now let's understand what threat of execution is.
+
+39
+00:02:51,000 --> 00:02:56,000
+Each process may be executed in one or more threats of execution.
+
+40
+00:02:56,000 --> 00:02:59,000
+In this case, our program is executed concurrently.
+
+41
+00:02:59,000 --> 00:03:03,000
+In other words, some instructions are executed in parallel.
+
+42
+00:03:03,000 --> 00:03:09,000
+In computer science, concurrency is a duplicate of different parts or units of a program algorithm
+
+43
+00:03:10,000 --> 00:03:17,000
+or problem to be executed out of order or at the same time simultaneously without affecting the final
+
+44
+00:03:17,000 --> 00:03:17,000
+outcome.
+
+45
+00:03:18,000 --> 00:03:22,000
+So we can say that each process may be executed in multiple threats.
+
+46
+00:03:23,000 --> 00:03:27,000
+In the learning literature, you might even find mention about different name of abstracts.
+
+47
+00:03:27,000 --> 00:03:34,000
+Sometimes they're called as lightweight processes or threats, share process resources.
+
+48
+00:03:34,000 --> 00:03:37,000
+This is something that may cause issues during the multithreaded.
+
+49
+00:03:38,000 --> 00:03:44,000
+If you're allocated two gigabytes for a GBM, that means all created stress will work within these two
+
+50
+00:03:44,000 --> 00:03:47,000
+gigabytes and we'll share in between each other.
+
+51
+00:03:48,000 --> 00:03:51,000
+Knowing your memory will be allocated to threat of execution.
+
+52
+00:03:52,000 --> 00:03:54,000
+I hope you already know the answer to my next question.
+
+53
+00:03:55,000 --> 00:03:56,000
+What is a move to threaten?
+
+54
+00:03:57,000 --> 00:04:01,000
+To threaten is the process of execution of program in multiple threats.
+
+55
+00:04:01,000 --> 00:04:04,000
+Most of the operating systems nowadays support this feature.
+
+56
+00:04:05,000 --> 00:04:11,000
+You have multiple course in your processa multithreaded allows you to use all course for execution of
+
+57
+00:04:11,000 --> 00:04:13,000
+your program instructions.
+
+58
+00:04:13,000 --> 00:04:21,000
+EPU executes one task at a time and we as the software engineers will write instructions how to split
+
+59
+00:04:22,000 --> 00:04:23,000
+between different threats of execution.
+
+60
+00:04:24,000 --> 00:04:25,000
+That's what we are going to learn.
+
+61
+00:04:26,000 --> 00:04:27,000
+Let me explain it now.
+
+62
+00:04:27,000 --> 00:04:32,000
+How multiscreen program works on the high level, you always have one threat of execution.
+
+63
+00:04:32,000 --> 00:04:34,000
+One program just started.
+
+64
+00:04:34,000 --> 00:04:36,000
+That is your main threat of execution.
+
+65
+00:04:37,000 --> 00:04:43,000
+After that, you can run so-called child threats of execution and describe instructions what those threats
+
+66
+00:04:43,000 --> 00:04:44,000
+should work on.
+
+67
+00:04:44,000 --> 00:04:48,000
+In parallel, the different use cases of using Otis Redding.
+
+68
+00:04:48,000 --> 00:04:49,000
+And we'll look at them in the minute.
+
+69
+00:04:50,000 --> 00:04:56,000
+And now the important thing, how to synchronize the work of different threats imagines at your peril
+
+70
+00:04:56,000 --> 00:04:58,000
+to your work between multiple threats.
+
+71
+00:04:59,000 --> 00:05:00,000
+It is another thing that.
+
+72
+00:05:00,000 --> 00:05:06,000
+All of the threats are part of one program, and sometimes threat needs to update on the man's threat
+
+73
+00:05:06,000 --> 00:05:09,000
+about state of execution or result of execution.
+
+74
+00:05:10,000 --> 00:05:15,000
+But sometimes threats also need to interact with each other, take into account all threats, working
+
+75
+00:05:15,000 --> 00:05:17,000
+with some shared resource.
+
+76
+00:05:17,000 --> 00:05:23,000
+To rephrase this in simple words, imagine that you have a collection of users and you need to filter
+
+77
+00:05:23,000 --> 00:05:28,000
+this collection and remove users that have less than one thousand dollars total.
+
+78
+00:05:28,000 --> 00:05:34,000
+Check in your online shop and you decided to split the task between different threats of execution.
+
+79
+00:05:34,000 --> 00:05:39,000
+Each threat of execution works with shared resource collection of users.
+
+80
+00:05:39,000 --> 00:05:46,000
+Each threat takes users from this common collection to provide the result of the specific part of namely
+
+81
+00:05:46,000 --> 00:05:53,000
+users are equally distributed between different threats but all threats to removing users from the common
+
+82
+00:05:53,000 --> 00:05:55,000
+collection shared between all of them.
+
+83
+00:05:55,000 --> 00:05:59,000
+Can you understand what the shared resource mean on this example?
+
+84
+00:06:00,000 --> 00:06:05,000
+Let's review also other use cases of multithreaded programming and the one we might want to use this
+
+85
+00:06:05,000 --> 00:06:05,000
+approach.
+
+86
+00:06:06,000 --> 00:06:08,000
+I believe that we have already discussed the first case.
+
+87
+00:06:09,000 --> 00:06:15,000
+That is the case when different threats on these slides are marked with capital key and numbers reaching
+
+88
+00:06:15,000 --> 00:06:22,000
+out to shared resource that is marked with capital are in this case to modify the state of the resource.
+
+89
+00:06:23,000 --> 00:06:27,000
+So next year's case of using multithreaded is reading and writing operations.
+
+90
+00:06:28,000 --> 00:06:33,000
+You know that in Java, most of the input output streams, blogs and in process of execution.
+
+91
+00:06:34,000 --> 00:06:37,000
+So why don't we use features of malicious reading?
+
+92
+00:06:37,000 --> 00:06:42,000
+And in case we need to write, let's say, some file, we do this in a separate thread.
+
+93
+00:06:42,000 --> 00:06:50,000
+For example, a user asked us to do an expert of all users to see format and wants to download this
+
+94
+00:06:50,000 --> 00:06:50,000
+info.
+
+95
+00:06:50,000 --> 00:06:52,000
+No problem at all.
+
+96
+00:06:52,000 --> 00:06:58,000
+We are writing a separate threat of execution and other parts of our program proceed, working without
+
+97
+00:06:58,000 --> 00:07:05,000
+any free's user still able to click on other buttons and perform other operations while file downloading
+
+98
+00:07:05,000 --> 00:07:06,000
+is in progress.
+
+99
+00:07:06,000 --> 00:07:07,000
+Is that clear?
+
+100
+00:07:07,000 --> 00:07:09,000
+Same situation with redundant info.
+
+101
+00:07:10,000 --> 00:07:16,000
+Let's create a separate threat of execution that will show a status of uploading, and once uploading
+
+102
+00:07:16,000 --> 00:07:21,000
+is finished, we will be notified about that fact and we'll proceed from there.
+
+103
+00:07:21,000 --> 00:07:27,000
+Pay attention to how your clips is working when your important project or performance some other operations.
+
+104
+00:07:28,000 --> 00:07:32,000
+Eclipse is also Java application was multithreaded feature inside.
+
+105
+00:07:32,000 --> 00:07:39,000
+When any operation is performed, UI is not completely blocked and you still can perform as operations
+
+106
+00:07:39,000 --> 00:07:40,000
+with the clips in parallel.
+
+107
+00:07:41,000 --> 00:07:47,000
+The third case is a case when once to produce some data and other thread consumes this data.
+
+108
+00:07:48,000 --> 00:07:54,000
+These threads are working independently and potentially may interact with the help of the queue between
+
+109
+00:07:54,000 --> 00:07:54,000
+each other.
+
+110
+00:07:55,000 --> 00:08:02,000
+On the slide here you can see that we have producer and consumer producer send some item ready for processing
+
+111
+00:08:02,000 --> 00:08:08,000
+to the queue and consumer take this item from the queue when ready to process the next item.
+
+112
+00:08:08,000 --> 00:08:12,000
+The next case is a typical scenario with writers and readers.
+
+113
+00:08:13,000 --> 00:08:19,000
+Imagine that you have some shared resource, some shared buffer, and from one side you have writers
+
+114
+00:08:19,000 --> 00:08:21,000
+that might be separate services.
+
+115
+00:08:21,000 --> 00:08:24,000
+Read that, write some information to the buffer.
+
+116
+00:08:24,000 --> 00:08:28,000
+It can be is a strong representation of new objects or requests to the app.
+
+117
+00:08:28,000 --> 00:08:30,000
+Literally everything.
+
+118
+00:08:30,000 --> 00:08:34,000
+And on the other side, you have readers that read data from the buffer.
+
+119
+00:08:35,000 --> 00:08:41,000
+This example is different from all previous ones that we have discussed because here we have some specific
+
+120
+00:08:41,000 --> 00:08:47,000
+conditions on the ones that can write to the buffer at the point of time readers can to read during
+
+121
+00:08:47,000 --> 00:08:53,000
+the writing, all the readers may read data simultaneously, will have similar tasks in this course.
+
+122
+00:08:53,000 --> 00:08:56,000
+And I will show you how to solve this task.
+
+123
+00:08:56,000 --> 00:08:58,000
+Really interesting, don't you think so?
+
+124
+00:08:59,000 --> 00:09:03,000
+Probably these are the most popular use cases of using an Otis Redding approach.
+
+125
+00:09:03,000 --> 00:09:10,000
+Definitely there will be variations of these use cases and sometimes even different scenarios, but
+
+126
+00:09:10,000 --> 00:09:13,000
+we'll try to cover as much as we can on this course.
+
+127
+00:09:13,000 --> 00:09:17,000
+Now let's discuss advantages and disadvantages of multi threading approach.
+
+128
+00:09:18,000 --> 00:09:20,000
+Let's start from advantages of multithreaded.
+
+129
+00:09:20,000 --> 00:09:22,000
+It was to name a few important ones.
+
+130
+00:09:22,000 --> 00:09:29,000
+They are effective use of multiple course of your processa, high performance of your program during
+
+131
+00:09:29,000 --> 00:09:32,000
+execution of specific operations and data processing.
+
+132
+00:09:33,000 --> 00:09:36,000
+Good to use with operations that block mansard of execution.
+
+133
+00:09:37,000 --> 00:09:43,000
+Like I said before, in case of working with input output streams, application responsiveness, if
+
+134
+00:09:43,000 --> 00:09:49,000
+there is a need to perform, some operation application won't be frozen until that operation is completed.
+
+135
+00:09:50,000 --> 00:09:53,000
+Instead, I will execute request in a separate thread.
+
+136
+00:09:54,000 --> 00:10:00,000
+Probably these are main advantages of using these advantages, maintaining the Australian approach.
+
+137
+00:10:00,000 --> 00:10:06,000
+Across all over the world and in different programming languages, but there are always two sides of
+
+138
+00:10:06,000 --> 00:10:10,000
+a metal, all these advantages come with a group of disadvantages.
+
+139
+00:10:10,000 --> 00:10:17,000
+Some of them are it is easy to use is written incorrectly by saying this, I would like to highlight
+
+140
+00:10:17,000 --> 00:10:18,000
+that using what is right.
+
+141
+00:10:18,000 --> 00:10:24,000
+And it requires a good understanding of the toolset to implement concurrent execution of your program.
+
+142
+00:10:24,000 --> 00:10:26,000
+And that is relatively easy to do.
+
+143
+00:10:26,000 --> 00:10:32,000
+A mistake, for example, in synchronous court, sometimes also of execution doesn't play a big role.
+
+144
+00:10:33,000 --> 00:10:39,000
+Or you can write code in different ways with the thread and it is not so easy and straightforward.
+
+145
+00:10:40,000 --> 00:10:46,000
+You need to be sure about what pieces of code you need to synchronize between different threads, how
+
+146
+00:10:46,000 --> 00:10:50,000
+much stress you need, how to split work between threads and so on.
+
+147
+00:10:50,000 --> 00:10:55,000
+Incorrect and suitable usage of Montasser in May cause your performance.
+
+148
+00:10:56,000 --> 00:11:00,000
+You need to understand that multithreaded works perfectly, not for all tasks.
+
+149
+00:11:01,000 --> 00:11:06,000
+For example, you might not always see the benefit of using what is written while working with small
+
+150
+00:11:06,000 --> 00:11:12,000
+data in case you want to implement a certain approach and filter an election was one hundred integers.
+
+151
+00:11:12,000 --> 00:11:18,000
+More likely, it will take more time than performing the same operation synchronously in one step.
+
+152
+00:11:19,000 --> 00:11:19,000
+Why?
+
+153
+00:11:20,000 --> 00:11:26,000
+Because running threads, synchronization time, corporatization of different threads on different CPUs.
+
+154
+00:11:26,000 --> 00:11:31,000
+All of this takes time and we need to be sure that when we apply to certain approach, it is really
+
+155
+00:11:31,000 --> 00:11:38,000
+worth it and we will benefit from this and some mistakes even can bring it to the deadlock and lifework
+
+156
+00:11:38,000 --> 00:11:39,000
+cases.
+
+157
+00:11:39,000 --> 00:11:45,000
+When your program doesn't perform any useful activity, hard to debark application and find the mistake,
+
+158
+00:11:46,000 --> 00:11:52,000
+it is much harder to replicate an error in the multithreaded application than it is to do so in a single
+
+159
+00:11:52,000 --> 00:11:53,000
+threaded application.
+
+160
+00:11:53,000 --> 00:11:58,000
+As a result, it is more difficult to identify and verify root causes when error.
+
+161
+00:11:58,000 --> 00:12:03,000
+Secure testing process of multithreaded app is more difficult.
+
+162
+00:12:03,000 --> 00:12:09,000
+Testing the multithreaded application is more difficult than testing a single application because the
+
+163
+00:12:09,000 --> 00:12:13,000
+effects are often timing related and more difficult to reproduce.
+
+164
+00:12:13,000 --> 00:12:19,000
+It is difficult to introduce notice writing approach already created code because all code needs to
+
+165
+00:12:19,000 --> 00:12:24,000
+be analyzed by engineers, static variables, methods and locations and critical areas.
+
+166
+00:12:24,000 --> 00:12:30,000
+Everything needs to be reviewed and adjusted to make sure that the implementation of concurrent programming
+
+167
+00:12:30,000 --> 00:12:32,000
+approach will not affect all application.
+
+168
+00:12:33,000 --> 00:12:39,000
+The main disadvantages of multithreaded that we also need to consider when we want to create scalable
+
+169
+00:12:39,000 --> 00:12:40,000
+app with high performance.
+
+170
+00:12:41,000 --> 00:12:47,000
+In this course, we are going to learn tools for concurrent programming most tools, classes and interfaces
+
+171
+00:12:47,000 --> 00:12:48,000
+allocated in Java.
+
+172
+00:12:48,000 --> 00:12:50,000
+You can current package.
+
+173
+00:12:50,000 --> 00:12:57,000
+This package also has some set packages, also some main types like Runnable and Thread located in general
+
+174
+00:12:57,000 --> 00:12:58,000
+and package.
+
+175
+00:12:58,000 --> 00:13:05,000
+But most of the classes and interfaces, including concurrent collections, locks and other mechanisms
+
+176
+00:13:05,000 --> 00:13:10,000
+for stress synchronization executer services and most of the things that we are going to learn allocated
+
+177
+00:13:10,000 --> 00:13:12,000
+individual concurrent package.
+
+178
+00:13:12,000 --> 00:13:15,000
+We have really a lot of interesting things to learn.
+
+179
+00:13:15,000 --> 00:13:19,000
+Now let's recap what we have learned in this lesson and this lesson.
+
+180
+00:13:19,000 --> 00:13:22,000
+We learned what the process is and what the threat is.
+
+181
+00:13:23,000 --> 00:13:28,000
+We also learned what is a multiscreen program programming now, you know, the most popular use cases
+
+182
+00:13:28,000 --> 00:13:30,000
+of not just training programs.
+
+183
+00:13:30,000 --> 00:13:34,000
+We learned advantages and disadvantages of concurrent programming.
+
+184
+00:13:35,000 --> 00:13:36,000
+That's all for this lesson.
+
+185
+00:13:36,000 --> 00:13:39,000
+Looking forward to seeing you in the next lesson.
+

27 - Multithreading/002 First Multithreading Program Thread & Runnable_en.srt

@@ -0,0 +1,1480 @@
+1
+00:00:05,000 --> 00:00:06,000
+Hello.
+
+2
+00:00:06,000 --> 00:00:09,000
+Yes, students in this class and will create our first multithreaded program.
+
+3
+00:00:10,000 --> 00:00:14,000
+It is time to put our theoretical knowledge on practice and learn new things.
+
+4
+00:00:14,000 --> 00:00:20,000
+We'll start from understanding of threat lifecycle and in which states our threat may be and when will
+
+5
+00:00:20,000 --> 00:00:22,000
+jump to practical examples.
+
+6
+00:00:22,000 --> 00:00:24,000
+You'll have enough knowledge to understand that.
+
+7
+00:00:25,000 --> 00:00:29,000
+And this lesson I will show you how to create a threat with five different ways.
+
+8
+00:00:29,000 --> 00:00:35,000
+We are going to learn such basic laws for multithreaded in general threat and one of the most important
+
+9
+00:00:35,000 --> 00:00:36,000
+interfaces.
+
+10
+00:00:36,000 --> 00:00:37,000
+Runnable.
+
+11
+00:00:37,000 --> 00:00:43,000
+While showing you examples, I will focus your attention on main properties of threat class to describe
+
+12
+00:00:43,000 --> 00:00:44,000
+each state.
+
+13
+00:00:44,000 --> 00:00:50,000
+And once we Iran's threats, we will learn with you how we can interact execution of a threat.
+
+14
+00:00:50,000 --> 00:00:56,000
+We'll discuss methods that are deprecated for a long time already and that you never should use.
+
+15
+00:00:56,000 --> 00:00:59,000
+And also we'll talk about proper ways of threat interaction.
+
+16
+00:01:00,000 --> 00:01:03,000
+Today, we're going to have a lot of good examples.
+
+17
+00:01:03,000 --> 00:01:09,000
+And as we will go over the examples, I will also explain specifics of some methods and behavior of
+
+18
+00:01:09,000 --> 00:01:09,000
+threats.
+
+19
+00:01:10,000 --> 00:01:10,000
+Let's start.
+
+20
+00:01:11,000 --> 00:01:17,000
+And as I said before, let's start from the understanding the whole lifecycle of a threat is considered
+
+21
+00:01:17,000 --> 00:01:18,000
+to be a new one.
+
+22
+00:01:18,000 --> 00:01:20,000
+We just created an object of a threat.
+
+23
+00:01:21,000 --> 00:01:23,000
+And you know that in Java, everything is an object.
+
+24
+00:01:24,000 --> 00:01:28,000
+That's why threat of execution is also an object to run a threat.
+
+25
+00:01:28,000 --> 00:01:35,000
+We need to start massive because mass that creates a separate threat of execution within the Java process.
+
+26
+00:01:36,000 --> 00:01:38,000
+After that threat is in the running state.
+
+27
+00:01:38,000 --> 00:01:44,000
+In this state, we can make our threat not run by turning our threat into waiting state or block state.
+
+28
+00:01:45,000 --> 00:01:50,000
+During this course, we will discuss all these scenarios, for example, when threat is blocked and
+
+29
+00:01:50,000 --> 00:01:57,000
+when it's waiting for now, you need just to understand that running threat may be put on pause and
+
+30
+00:01:57,000 --> 00:02:01,000
+getting back to running state again as engineers will learn how to do this.
+
+31
+00:02:02,000 --> 00:02:06,000
+Sometimes threats waiting their chance to update a shared resource.
+
+32
+00:02:06,000 --> 00:02:12,000
+Sometimes we want to make a threat, wait until other threats will adjust it of our shared resource.
+
+33
+00:02:12,000 --> 00:02:16,000
+And the last possible state of our threat is a Terminator's state.
+
+34
+00:02:16,000 --> 00:02:21,000
+This state tells us that threat finished its execution or it was interrupted.
+
+35
+00:02:22,000 --> 00:02:24,000
+Is it clear now when you're no threat?
+
+36
+00:02:24,000 --> 00:02:27,000
+Life-cycle it is time to write our first.
+
+37
+00:02:27,000 --> 00:02:32,000
+Just read an application I open file was named first just writing program.
+
+38
+00:02:32,000 --> 00:02:34,000
+I have main message here.
+
+39
+00:02:34,000 --> 00:02:37,000
+Let me go line by line and explain you each role here.
+
+40
+00:02:38,000 --> 00:02:44,000
+You can see that the first thing that I do here, I declare a variable of type Runnable and initialize
+
+41
+00:02:44,000 --> 00:02:46,000
+it with new object of type default.
+
+42
+00:02:46,000 --> 00:02:47,000
+Runnable.
+
+43
+00:02:47,000 --> 00:02:52,000
+Let me open source code of Runnable type, because you see this time the first time in this course,
+
+44
+00:02:53,000 --> 00:02:56,000
+as you can see, this is an interface from the Java version.
+
+45
+00:02:56,000 --> 00:03:01,000
+What does a functional interface was only one abasic mass with name.
+
+46
+00:03:01,000 --> 00:03:01,000
+Right.
+
+47
+00:03:02,000 --> 00:03:06,000
+We see that this method returns nassan and return type is void.
+
+48
+00:03:06,000 --> 00:03:13,000
+This is exactly the method that we need to implement and where we need to put a code that will be executed
+
+49
+00:03:13,000 --> 00:03:18,000
+in the separate thread to have separate thread, we need to have instructions about what this thread
+
+50
+00:03:18,000 --> 00:03:23,000
+is supposed to do and these instructions should be written somewhere.
+
+51
+00:03:23,000 --> 00:03:26,000
+This is exactly the method that will be executed by thread.
+
+52
+00:03:27,000 --> 00:03:33,000
+Let's now check the source code of a default runnable we see as a default Runnable implements Runnable
+
+53
+00:03:33,000 --> 00:03:34,000
+interface.
+
+54
+00:03:34,000 --> 00:03:41,000
+Basically, this is my custom clause that gives implementation to run Macel inside this matter.
+
+55
+00:03:41,000 --> 00:03:43,000
+I print such text to console.
+
+56
+00:03:43,000 --> 00:03:45,000
+I'm a new threat.
+
+57
+00:03:45,000 --> 00:03:52,000
+My name is and here I call static method on class will learn this class in a minute.
+
+58
+00:03:52,000 --> 00:03:58,000
+But just to finish explanation of this line, current threat is a static method of threat class that
+
+59
+00:03:58,000 --> 00:04:00,000
+returns the reference to the threat object.
+
+60
+00:04:01,000 --> 00:04:08,000
+And depending on where this method is invoked, we receive the reference to the object of current threat.
+
+61
+00:04:08,000 --> 00:04:13,000
+And after that I just call that name method that returns is a name of the threat.
+
+62
+00:04:13,000 --> 00:04:18,000
+I want to bring this text to console to prove that we have separate threat of execution.
+
+63
+00:04:18,000 --> 00:04:20,000
+One will run our app.
+
+64
+00:04:20,000 --> 00:04:24,000
+But before doing that, let's investigate threat glass.
+
+65
+00:04:24,000 --> 00:04:26,000
+Let me open the source code of this class.
+
+66
+00:04:27,000 --> 00:04:31,000
+The first thing is that you can notice here is that threat also implements Runnable.
+
+67
+00:04:32,000 --> 00:04:33,000
+What does this mean?
+
+68
+00:04:33,000 --> 00:04:38,000
+This means that the object of threat type also may be executed as a separate threat.
+
+69
+00:04:38,000 --> 00:04:42,000
+And this class also has implementation of around MassArt.
+
+70
+00:04:42,000 --> 00:04:43,000
+Let's look at it.
+
+71
+00:04:43,000 --> 00:04:49,000
+As we can see, the first things that object will try to do is to check whether we have target field
+
+72
+00:04:49,000 --> 00:04:49,000
+initialized.
+
+73
+00:04:49,000 --> 00:04:53,000
+And if yes, then we'll call run Masset on that object.
+
+74
+00:04:54,000 --> 00:04:57,000
+And if not, then we'll just do nothing.
+
+75
+00:04:57,000 --> 00:05:02,000
+Target Field has Runnable type and we can see even Kermanshah above this field.
+
+76
+00:05:02,000 --> 00:05:03,000
+This is something.
+
+77
+00:05:03,000 --> 00:05:08,000
+What will be around so as you can understand, we can do two things here.
+
+78
+00:05:08,000 --> 00:05:16,000
+We can pass Runnable object to the threat glass or we can override run Masad in Third-Class, we can
+
+79
+00:05:16,000 --> 00:05:18,000
+pass Runnable to this class.
+
+80
+00:05:18,000 --> 00:05:19,000
+We are constructor.
+
+81
+00:05:19,000 --> 00:05:23,000
+We have really a lot of different versions of constructor for this type.
+
+82
+00:05:23,000 --> 00:05:30,000
+And one of the constructor is to accept and initialize target field to store the reference to the Runnable
+
+83
+00:05:30,000 --> 00:05:30,000
+object.
+
+84
+00:05:31,000 --> 00:05:37,000
+Interesting thing to notice here is that this constructor invokes another version of constructor.
+
+85
+00:05:37,000 --> 00:05:39,000
+It passes in reference to the REDgroup.
+
+86
+00:05:40,000 --> 00:05:42,000
+We'll discuss a little bit later.
+
+87
+00:05:42,000 --> 00:05:48,000
+What does it reference to our Runnable object name of the thread, which consists of the word thread
+
+88
+00:05:48,000 --> 00:05:50,000
+dash and the sequential number.
+
+89
+00:05:50,000 --> 00:05:53,000
+Is it a static variable name thread in it?
+
+90
+00:05:53,000 --> 00:06:00,000
+No, that is incremented every time when the next threatener method and the last argument is a stack
+
+91
+00:06:00,000 --> 00:06:07,000
+size zero because according to the recommendation, in case this argument is zero, we have no requirement
+
+92
+00:06:07,000 --> 00:06:09,000
+for specific text size for this new threat.
+
+93
+00:06:10,000 --> 00:06:15,000
+And the new constructor Interent calls new constructor that passes to more arguments.
+
+94
+00:06:15,000 --> 00:06:23,000
+New and true new value is supposed to cover such constructor argument as access control context and
+
+95
+00:06:23,000 --> 00:06:29,000
+true value is the flag to indicate whether we need to inherit initial values for inheritable threat
+
+96
+00:06:29,000 --> 00:06:31,000
+logos from the construction threat.
+
+97
+00:06:32,000 --> 00:06:34,000
+Let me explain what these things meant.
+
+98
+00:06:35,000 --> 00:06:42,000
+Access control context is a type that is used to create objects that make system access decisions based
+
+99
+00:06:42,000 --> 00:06:44,000
+on the context it encapsulates.
+
+100
+00:06:44,000 --> 00:06:50,000
+Check permission Massada that is invoked in the context that access control context encapsulates inside
+
+101
+00:06:51,000 --> 00:06:56,000
+is allowed to process was access to resources or access control exception.
+
+102
+00:06:56,000 --> 00:07:00,000
+Anyway, this is not the topic for the first lesson of not just reading.
+
+103
+00:07:00,000 --> 00:07:04,000
+And this is not what you will use on a daily basis directly while working with me.
+
+104
+00:07:04,000 --> 00:07:05,000
+Just read it.
+
+105
+00:07:05,000 --> 00:07:07,000
+But just in order to let you know.
+
+106
+00:07:08,000 --> 00:07:10,000
+Regarding the second argument inherits read.
+
+107
+00:07:10,000 --> 00:07:13,000
+Locals do not pay a lot of attention to this one.
+
+108
+00:07:13,000 --> 00:07:20,000
+And this moment will cover concept of threat locals and inheritable threat local separately, but ensured
+
+109
+00:07:20,000 --> 00:07:26,000
+this flag is to tell threat whether we need to inherit values from inheritable threat local from the
+
+110
+00:07:26,000 --> 00:07:27,000
+construction threat.
+
+111
+00:07:27,000 --> 00:07:32,000
+And basically after that we proceed with construction of our threat of execution.
+
+112
+00:07:33,000 --> 00:07:38,000
+Besides the construction of Runnable that we have just discussed, we have also different constructors
+
+113
+00:07:38,000 --> 00:07:44,000
+that initializes other properties of threat object, for example, threat that takes Runnable and access
+
+114
+00:07:44,000 --> 00:07:51,000
+control context, constructor that takes REDgroup and Runnable also another popular constructor for
+
+115
+00:07:51,000 --> 00:07:54,000
+the bag and purposes is constructor with Runnable and string.
+
+116
+00:07:54,000 --> 00:08:00,000
+String represents the name of the threat and other different variations, including constructors with
+
+117
+00:08:00,000 --> 00:08:04,000
+taxes and boolean flag to indicate the state of the inherited threat.
+
+118
+00:08:04,000 --> 00:08:05,000
+The locals flag.
+
+119
+00:08:06,000 --> 00:08:07,000
+What are the properties?
+
+120
+00:08:07,000 --> 00:08:08,000
+The threat glass half.
+
+121
+00:08:09,000 --> 00:08:16,000
+If we would scroll to the top of this file, will find properties that we also may use during the configuration
+
+122
+00:08:16,000 --> 00:08:16,000
+of the threat.
+
+123
+00:08:17,000 --> 00:08:19,000
+You already know about threatening property.
+
+124
+00:08:20,000 --> 00:08:22,000
+By the way, here is also new keyword for you.
+
+125
+00:08:23,000 --> 00:08:24,000
+Volatile will cover it.
+
+126
+00:08:24,000 --> 00:08:28,000
+Do in the separate lesson we have priority property.
+
+127
+00:08:29,000 --> 00:08:35,000
+This is a from one to 10 that will be used by threat scheduler to decide what threat is more important
+
+128
+00:08:35,000 --> 00:08:36,000
+to work with.
+
+129
+00:08:36,000 --> 00:08:43,000
+So this next, however, we never can rely on the priority property when we have concurrent threat executed.
+
+130
+00:08:43,000 --> 00:08:49,000
+Let's call this recommendation, but not mandatory direction to follow for threats.
+
+131
+00:08:49,000 --> 00:08:50,000
+Catala What is a threat?
+
+132
+00:08:50,000 --> 00:08:54,000
+Skalla It is part of GM that decides which threats should run.
+
+133
+00:08:55,000 --> 00:08:58,000
+Also, it decides which threats should wait, how it is.
+
+134
+00:08:59,000 --> 00:09:03,000
+This is a great question, but probably not for the first practical move.
+
+135
+00:09:03,000 --> 00:09:06,000
+This riding lesson will also cover this topic separately.
+
+136
+00:09:07,000 --> 00:09:10,000
+The next property here is on by default.
+
+137
+00:09:10,000 --> 00:09:11,000
+It is false.
+
+138
+00:09:12,000 --> 00:09:16,000
+We will discuss later in this course what demons threats are interrupted.
+
+139
+00:09:16,000 --> 00:09:23,000
+Flag is used to indicate where the threat is interrupted and we need to stop its execution or we need
+
+140
+00:09:23,000 --> 00:09:25,000
+to proceed execution of a threat.
+
+141
+00:09:25,000 --> 00:09:26,000
+Let in this lesson.
+
+142
+00:09:26,000 --> 00:09:30,000
+I will also show you how to interact with this property.
+
+143
+00:09:31,000 --> 00:09:33,000
+Maxfield's here used by Jovian.
+
+144
+00:09:33,000 --> 00:09:36,000
+We will not focus our attention on them in this lesson.
+
+145
+00:09:37,000 --> 00:09:40,000
+And probably the one property that we did not talk yet is a threat.
+
+146
+00:09:40,000 --> 00:09:48,000
+The group this object is used to groups threats to gather in one group support group forms a three and
+
+147
+00:09:48,000 --> 00:09:50,000
+every threat except a regional threat.
+
+148
+00:09:50,000 --> 00:09:51,000
+The group has a parent.
+
+149
+00:09:52,000 --> 00:09:58,000
+There are also some specific self-locking mechanism for threat in that group, but probably will cover
+
+150
+00:09:58,000 --> 00:09:59,000
+this in a separate lesson.
+
+151
+00:10:00,000 --> 00:10:03,000
+And it looks like that Tetragon high level of.
+
+152
+00:10:03,000 --> 00:10:10,000
+You officer red class and its properties definitely as more things to learn here, but we'll do it gradually
+
+153
+00:10:10,000 --> 00:10:12,000
+and with practical examples, case by case.
+
+154
+00:10:13,000 --> 00:10:15,000
+Now, let's get back to the demo file here.
+
+155
+00:10:15,000 --> 00:10:20,000
+You can see that I created a threat object and positive reference to the Runnable object.
+
+156
+00:10:20,000 --> 00:10:25,000
+Why option was a separate class might be needed in this case.
+
+157
+00:10:25,000 --> 00:10:27,000
+You can declare some files if needed.
+
+158
+00:10:28,000 --> 00:10:34,000
+Also, you can declare constructors and pass external resources to the new objects if needed, because
+
+159
+00:10:34,000 --> 00:10:38,000
+by default, ranma, it doesn't take anything as Masset argument.
+
+160
+00:10:38,000 --> 00:10:43,000
+And here's just an example of constructor initialization of the state of this object.
+
+161
+00:10:44,000 --> 00:10:51,000
+If we want, we can pass any external object to the constructor and use the state of our runnable object
+
+162
+00:10:51,000 --> 00:10:53,000
+in one method if needed.
+
+163
+00:10:53,000 --> 00:10:58,000
+In such a way you can just share the resource that we shared with this thread.
+
+164
+00:10:59,000 --> 00:11:05,000
+This is basically the first way to create a threat object that is ready to be executed and that is in
+
+165
+00:11:05,000 --> 00:11:06,000
+your state.
+
+166
+00:11:06,000 --> 00:11:09,000
+The next way is another variation of the first one.
+
+167
+00:11:10,000 --> 00:11:15,000
+Instead of creating type that implements Runnable, we can just pass instance of anonymous class.
+
+168
+00:11:16,000 --> 00:11:19,000
+You can see here that I have similar method implemented.
+
+169
+00:11:20,000 --> 00:11:22,000
+Basically nothing special to highlight here.
+
+170
+00:11:23,000 --> 00:11:27,000
+And to be honest, this way of creating threat is not very popular.
+
+171
+00:11:28,000 --> 00:11:34,000
+The next way to great threat is to extend a new class from the threat and all around Massett, if you
+
+172
+00:11:34,000 --> 00:11:41,000
+remember when we were you in threat object, we saw that there is nothing to execute by default if we
+
+173
+00:11:41,000 --> 00:11:44,000
+didn't pass the reference to the Runnable object.
+
+174
+00:11:44,000 --> 00:11:48,000
+That's why so radically we can just override one method.
+
+175
+00:11:49,000 --> 00:11:54,000
+You can see that the current class extends threat clause and we overwrite one method here.
+
+176
+00:11:55,000 --> 00:12:00,000
+And after that, the main method is simply create the object of the first sorting program type.
+
+177
+00:12:01,000 --> 00:12:01,000
+That's it.
+
+178
+00:12:02,000 --> 00:12:08,000
+While this option often described in the literature, don't recommend it to you this way.
+
+179
+00:12:08,000 --> 00:12:08,000
+Why?
+
+180
+00:12:09,000 --> 00:12:13,000
+Because he extends that class just to overwrite one method.
+
+181
+00:12:13,000 --> 00:12:18,000
+Probably it is not the best approach from the single responsibility principle point of view.
+
+182
+00:12:19,000 --> 00:12:25,000
+For such purposes we have Runnable type and we can use it to give implementation to run Macit.
+
+183
+00:12:25,000 --> 00:12:32,000
+The fourth way to prepare a threat for execution is to use lambda expression to implement around Macit.
+
+184
+00:12:32,000 --> 00:12:34,000
+She can see that I created lambda function.
+
+185
+00:12:34,000 --> 00:12:37,000
+That takes no arguments and returns nassan.
+
+186
+00:12:38,000 --> 00:12:44,000
+Basically I just print the same text and the last, but not least for today, is the way preparing A
+
+187
+00:12:45,000 --> 00:12:46,000
+was MassArt reference.
+
+188
+00:12:46,000 --> 00:12:53,000
+I have a static method declared in this class with name execute that takes no parameters and that brings
+
+189
+00:12:53,000 --> 00:12:55,000
+the same text to cancel.
+
+190
+00:12:55,000 --> 00:13:00,000
+I just passing method reference here that meets the definition of Runnable interface.
+
+191
+00:13:00,000 --> 00:13:06,000
+It doesn't take any arguments and it returns nassan the same as around Massett.
+
+192
+00:13:06,000 --> 00:13:12,000
+In case you are not familiar with lambda functions and method references in Java, but you want to learn
+
+193
+00:13:12,000 --> 00:13:12,000
+that.
+
+194
+00:13:13,000 --> 00:13:16,000
+Check my functional programming course for Java InGenius.
+
+195
+00:13:16,000 --> 00:13:22,000
+We have really a lot of examples that the next thing that you see in this line and a sprinkling of the
+
+196
+00:13:22,000 --> 00:13:27,000
+current threat to console and for the sake of example, call run Nassib.
+
+197
+00:13:27,000 --> 00:13:36,000
+Remember, Run Masset doesn't start as a threat of execution, only start MassArt starts separate thread.
+
+198
+00:13:36,000 --> 00:13:42,000
+But if you would call directly around MassArt, you would just execute run MassArt synchronously.
+
+199
+00:13:43,000 --> 00:13:47,000
+And after that I call starts MassArt on each thread that we created here.
+
+200
+00:13:47,000 --> 00:13:53,000
+Let's run the program to see what we have got in the console in the first line with the printed text
+
+201
+00:13:53,000 --> 00:14:02,000
+from my main threat here you can see the text current threatening is and its name is Main Man is the
+
+202
+00:14:02,000 --> 00:14:09,000
+name of the first read that we have in our Java application is the next line is a result of invocation
+
+203
+00:14:09,000 --> 00:14:10,000
+of FRAND method.
+
+204
+00:14:10,000 --> 00:14:13,000
+And as you can see, threatening is still man.
+
+205
+00:14:13,000 --> 00:14:19,000
+That proves that invocation of method doesn't actually start a new threat.
+
+206
+00:14:20,000 --> 00:14:27,000
+And to start a new threat, we need to start Macit after you can see multiple lines with different names
+
+207
+00:14:27,000 --> 00:14:28,000
+of a threat.
+
+208
+00:14:29,000 --> 00:14:34,000
+That is exactly what is returned by getting the same method on the current threat involved from the
+
+209
+00:14:34,000 --> 00:14:35,000
+threat.
+
+210
+00:14:35,000 --> 00:14:42,000
+And you remember that by default, naming convention for each threat is threat word and sequential number
+
+211
+00:14:42,000 --> 00:14:42,000
+of a threat.
+
+212
+00:14:43,000 --> 00:14:47,000
+Can you understand now how to run your threat in real life?
+
+213
+00:14:47,000 --> 00:14:50,000
+You often use executor's to run and manage.
+
+214
+00:14:50,000 --> 00:14:53,000
+Your threats will learn executor's later in this course.
+
+215
+00:14:54,000 --> 00:15:00,000
+But what we have learned in this lesson, this is basics that you need to understand before moving further.
+
+216
+00:15:01,000 --> 00:15:02,000
+Now, what do we know how?
+
+217
+00:15:03,000 --> 00:15:08,000
+To start the threat, let's learn how to interact and stop its execution.
+
+218
+00:15:08,000 --> 00:15:16,000
+I have separate file for that was name interrupt them is interesting app that will help you to understand
+
+219
+00:15:16,000 --> 00:15:17,000
+how threat interception works.
+
+220
+00:15:18,000 --> 00:15:20,000
+Let's start from the main mast.
+
+221
+00:15:20,000 --> 00:15:24,000
+The first thing that I do here, create a task for execution.
+
+222
+00:15:24,000 --> 00:15:31,000
+I implement it runnable interface in this class for the sake of this demo and not having multiple classes
+
+223
+00:15:31,000 --> 00:15:31,000
+in this example.
+
+224
+00:15:32,000 --> 00:15:35,000
+I will show you around Massud in the minute after this.
+
+225
+00:15:35,000 --> 00:15:41,000
+I create a threat object and start a threat and I won't let the main threat sleep for two seconds and
+
+226
+00:15:41,000 --> 00:15:44,000
+interrupt my task after two seconds.
+
+227
+00:15:44,000 --> 00:15:45,000
+How I can do this?
+
+228
+00:15:46,000 --> 00:15:49,000
+I invoke sleep masset on the threat object.
+
+229
+00:15:49,000 --> 00:15:53,000
+This method takes a number of milliseconds as Masset argument.
+
+230
+00:15:54,000 --> 00:15:57,000
+Two seconds are equal to two thousand milliseconds.
+
+231
+00:15:57,000 --> 00:16:00,000
+Sleep method is our law that in threat class.
+
+232
+00:16:01,000 --> 00:16:02,000
+Let's look at the threat clause.
+
+233
+00:16:02,000 --> 00:16:03,000
+Source code.
+
+234
+00:16:03,000 --> 00:16:05,000
+We have to sleep massas here.
+
+235
+00:16:05,000 --> 00:16:12,000
+One was milliseconds only and another one takes two arguments, milliseconds and nanoseconds.
+
+236
+00:16:12,000 --> 00:16:14,000
+To be honest, I never used sleep mass.
+
+237
+00:16:14,000 --> 00:16:19,000
+It was nanoseconds, but still it is good to know that such method exists.
+
+238
+00:16:19,000 --> 00:16:26,000
+Let's get back to our demo file, another really user friendly interface of making sure that sleep is
+
+239
+00:16:26,000 --> 00:16:28,000
+to use time unit in from Javitz.
+
+240
+00:16:28,000 --> 00:16:29,000
+You can current package.
+
+241
+00:16:30,000 --> 00:16:36,000
+This enum represents time duration at the given unit of granularity and provides methods to convert
+
+242
+00:16:36,000 --> 00:16:40,000
+across units and perform timing and delay operations.
+
+243
+00:16:40,000 --> 00:16:47,000
+In these units, for example, you may perform such operations as making Meinzer slip, and the interface
+
+244
+00:16:47,000 --> 00:16:52,000
+allows us to not calculate milliseconds and convert them between seconds and other time units.
+
+245
+00:16:52,000 --> 00:16:53,000
+One unit.
+
+246
+00:16:53,000 --> 00:16:59,000
+But we can just take time units that we need and parse the value of the specific time unit that we need.
+
+247
+00:17:00,000 --> 00:17:03,000
+For example, here is a line similar to the one above.
+
+248
+00:17:04,000 --> 00:17:10,000
+It also uses milliseconds time unit and here is a line that use a second time unit.
+
+249
+00:17:10,000 --> 00:17:12,000
+And I'm just saying two seconds.
+
+250
+00:17:12,000 --> 00:17:16,000
+To be honest, in my opinion, using this API is more preferable.
+
+251
+00:17:17,000 --> 00:17:24,000
+And after this line, my main threat is in on the running state, in wait in state and the one threat
+
+252
+00:17:24,000 --> 00:17:26,000
+is awaiting as a threat may interrupt it.
+
+253
+00:17:27,000 --> 00:17:31,000
+That's why Slakey method maestro so called interrupted exception.
+
+254
+00:17:32,000 --> 00:17:39,000
+And that's why Compiler makes us handle this exception case to describe how a system should behave in
+
+255
+00:17:39,000 --> 00:17:41,000
+case somebody will interrupt this thread.
+
+256
+00:17:41,000 --> 00:17:46,000
+In this example, nobody will interrupt main threat but still interrupted.
+
+257
+00:17:46,000 --> 00:17:47,000
+Exception is checked.
+
+258
+00:17:47,000 --> 00:17:53,000
+That's why we need Searls declaration here in Maine method because for the sake of this demo, I don't
+
+259
+00:17:53,000 --> 00:17:55,000
+want to create try catch block here.
+
+260
+00:17:55,000 --> 00:17:59,000
+After that I print a console that I interact as a threat.
+
+261
+00:18:00,000 --> 00:18:01,000
+To interrupt as a threat.
+
+262
+00:18:01,000 --> 00:18:07,000
+We should call interrupt method interrupt method interruption flag inside the threat object.
+
+263
+00:18:08,000 --> 00:18:12,000
+That flag basically has two possible values, true or false.
+
+264
+00:18:12,000 --> 00:18:19,000
+With the help of this method, we can change the state of the interaction flag inside the threat and
+
+265
+00:18:19,000 --> 00:18:23,000
+the last line and my main threat is print and leave in the console.
+
+266
+00:18:23,000 --> 00:18:27,000
+Let's now look at our task and understand how interrupt.
+
+267
+00:18:27,000 --> 00:18:30,000
+Masset interrupts execution of the threat.
+
+268
+00:18:30,000 --> 00:18:32,000
+I open one method.
+
+269
+00:18:32,000 --> 00:18:39,000
+I print text that indicates that I entered one method and the threat is about to execute Vork method.
+
+270
+00:18:40,000 --> 00:18:41,000
+I invoke Vork method.
+
+271
+00:18:42,000 --> 00:18:43,000
+Let's look at it now.
+
+272
+00:18:44,000 --> 00:18:47,000
+Work method is that was the infinite loop.
+
+273
+00:18:47,000 --> 00:18:49,000
+After that we just print one word.
+
+274
+00:18:50,000 --> 00:18:52,000
+Verkin in f close.
+
+275
+00:18:52,000 --> 00:18:55,000
+I check if threat is interrupted is interrupted.
+
+276
+00:18:55,000 --> 00:19:02,000
+Matthew Chance is a state of the interaction flat and in case somebody from as a threat called MassArt
+
+277
+00:19:02,000 --> 00:19:07,000
+interrupt like we did in our main threat, then this method will return.
+
+278
+00:19:07,000 --> 00:19:07,000
+True.
+
+279
+00:19:08,000 --> 00:19:13,000
+Right now you already know what is done by interrupt and by is interrupted masses.
+
+280
+00:19:14,000 --> 00:19:16,000
+But why do we need interrupted?
+
+281
+00:19:16,000 --> 00:19:24,000
+Macit interrupted Massata returns also boolean value and return state of the interaction flac but it
+
+282
+00:19:24,000 --> 00:19:28,000
+also clears it and return it back to false.
+
+283
+00:19:28,000 --> 00:19:35,000
+So in case what uncommon this line and will executed interruption flag will be turned back to false
+
+284
+00:19:35,000 --> 00:19:36,000
+again.
+
+285
+00:19:36,000 --> 00:19:42,000
+To interrupt this thread I will keep this line commanded and we'll just leave it as an example for you.
+
+286
+00:19:42,000 --> 00:19:49,000
+By the way, I encourage you to download this service code example from the GitHub and run it locally
+
+287
+00:19:49,000 --> 00:19:49,000
+on your computer.
+
+288
+00:19:50,000 --> 00:19:55,000
+By doing this, you can play with values and comment and comment the lines that you are interested in
+
+289
+00:19:55,000 --> 00:20:00,000
+and as always, service code examples in attachments to this lesson.
+
+290
+00:20:00,000 --> 00:20:02,000
+OK, so now I believe.
+
+291
+00:20:03,000 --> 00:20:08,000
+The difference between these three methods interact is interrupted and interrupted.
+
+292
+00:20:08,000 --> 00:20:14,000
+Now pay attention that threat is moved to the white state because and will sleep mass at here.
+
+293
+00:20:14,000 --> 00:20:21,000
+And by the way, no matter how long sleep will be, I put one millisecond here for sleep.
+
+294
+00:20:21,000 --> 00:20:24,000
+But still, it is enough to interrupt the threat.
+
+295
+00:20:24,000 --> 00:20:25,000
+What will happen?
+
+296
+00:20:25,000 --> 00:20:28,000
+One threat will be a sleep take into account.
+
+297
+00:20:28,000 --> 00:20:35,000
+I'm in this safe block because interrupted FLAC is equal to true and the threat is invading state.
+
+298
+00:20:35,000 --> 00:20:38,000
+My threat will be interrupted and interrupted.
+
+299
+00:20:38,000 --> 00:20:40,000
+Exceptions will be thrown.
+
+300
+00:20:40,000 --> 00:20:48,000
+This line will not be executed never because interrupted exception will be thrown this mass Atheros
+
+301
+00:20:48,000 --> 00:20:52,000
+interrupted exception without any handlin to the upper level.
+
+302
+00:20:53,000 --> 00:20:58,000
+And here we should print interrupted in the work method and return from around Macit.
+
+303
+00:20:58,000 --> 00:21:05,000
+As you can see here, I have tried Kedge Block because sleep mass my throat checked exception and work
+
+304
+00:21:05,000 --> 00:21:08,000
+method doesn't handle this potential exception inside.
+
+305
+00:21:08,000 --> 00:21:11,000
+Let's run this program now for two seconds.
+
+306
+00:21:11,000 --> 00:21:18,000
+Program will bring to console working until threat will be interrupted and once it is interrupted,
+
+307
+00:21:18,000 --> 00:21:19,000
+let's see what we have.
+
+308
+00:21:19,000 --> 00:21:26,000
+The first thing that happened is threat interruption and even after that you can see that I printed
+
+309
+00:21:26,000 --> 00:21:27,000
+reconvert.
+
+310
+00:21:27,000 --> 00:21:34,000
+That is because I just changed interaction flac and I still need to wait until the threat will be in
+
+311
+00:21:34,000 --> 00:21:34,000
+a waiting mode.
+
+312
+00:21:35,000 --> 00:21:43,000
+This text in the main living tells us that Main Street finished its execution and after that we see
+
+313
+00:21:43,000 --> 00:21:44,000
+that we enter it if block.
+
+314
+00:21:44,000 --> 00:21:47,000
+And here is a status of interrupted flac.
+
+315
+00:21:47,000 --> 00:21:49,000
+It is equal to true.
+
+316
+00:21:49,000 --> 00:21:56,000
+The next step in our execution is entering the catch block and print and that threat was interrupted
+
+317
+00:21:56,000 --> 00:21:56,000
+in the work.
+
+318
+00:21:56,000 --> 00:21:57,000
+MassArt.
+
+319
+00:21:57,000 --> 00:21:58,000
+That's it.
+
+320
+00:21:59,000 --> 00:22:05,000
+So the rule of thumb, when you're creating all rain app, think about what is a logical point in your
+
+321
+00:22:05,000 --> 00:22:08,000
+thread to allow other threats to interrupt it.
+
+322
+00:22:08,000 --> 00:22:12,000
+In case you have such possibility to introduce this point, do it.
+
+323
+00:22:13,000 --> 00:22:16,000
+Usually you would let your threat fall asleep.
+
+324
+00:22:16,000 --> 00:22:21,000
+After all, resources are adjusted and state of the system is consistent.
+
+325
+00:22:21,000 --> 00:22:24,000
+In this case, there is no harm to interrupt the threat.
+
+326
+00:22:25,000 --> 00:22:31,000
+There are some methods that you should never use and that are marked as deprecated but not removed from
+
+327
+00:22:31,000 --> 00:22:34,000
+Janicki only because of the backwards compatibility.
+
+328
+00:22:34,000 --> 00:22:38,000
+Ziya, stop, suspend and resume.
+
+329
+00:22:39,000 --> 00:22:46,000
+These are dangerous masses in terms they are stop, suspend or resume threat execution instantly without
+
+330
+00:22:46,000 --> 00:22:47,000
+bothering.
+
+331
+00:22:47,000 --> 00:22:53,000
+What process is happening right now inside the threat, taking into account not all operations at ATOMIC
+
+332
+00:22:53,000 --> 00:22:57,000
+and performed with one single operation of updating data in the memory.
+
+333
+00:22:58,000 --> 00:23:01,000
+You can start somewhere in the middle of data processing in your threat.
+
+334
+00:23:02,000 --> 00:23:05,000
+At the meantime, resource will be updated as a threat.
+
+335
+00:23:05,000 --> 00:23:11,000
+And when you will resume execution, you may end up with not consistent state of your objects.
+
+336
+00:23:11,000 --> 00:23:18,000
+We will talk about atomic operations in adolescence, but I believe you understood that stopping a suspension
+
+337
+00:23:18,000 --> 00:23:25,000
+and after that resume and execution of the threat in case it is made some calculation process is not
+
+338
+00:23:25,000 --> 00:23:26,000
+the best idea.
+
+339
+00:23:26,000 --> 00:23:29,000
+And one more interesting and lasting for today's lesson.
+
+340
+00:23:30,000 --> 00:23:34,000
+Probably you saw one comment line here where I invoke June Masset.
+
+341
+00:23:35,000 --> 00:23:36,000
+What is it?
+
+342
+00:23:36,000 --> 00:23:40,000
+Let me uncommented first and run up one more time.
+
+343
+00:23:40,000 --> 00:23:44,000
+What's changed now in this version line?
+
+344
+00:23:44,000 --> 00:23:47,000
+Zatarain's in the main Leesville will always be printed.
+
+345
+00:23:47,000 --> 00:23:48,000
+Lost.
+
+346
+00:23:48,000 --> 00:23:49,000
+Why?
+
+347
+00:23:49,000 --> 00:23:56,000
+Because Join Masset also put our main threat in great state until this threat will be completely finished.
+
+348
+00:23:56,000 --> 00:23:59,000
+So I gave a command with this line to join.
+
+349
+00:23:59,000 --> 00:24:01,000
+This thread does a current one.
+
+350
+00:24:02,000 --> 00:24:08,000
+That's why my app will wait until Perry's threat will be completely executed during Masad.
+
+351
+00:24:08,000 --> 00:24:15,000
+Also, Masroor interrupted exception, taking into account it puts current threat wait in state and
+
+352
+00:24:15,000 --> 00:24:20,000
+other threats might interrupt this threat while it is innervate state.
+
+353
+00:24:20,000 --> 00:24:21,000
+Is it clear?
+
+354
+00:24:21,000 --> 00:24:25,000
+Basically, that's all what I wanted to share with you in this lesson.
+
+355
+00:24:26,000 --> 00:24:28,000
+Let's recap what we have learned today.
+
+356
+00:24:28,000 --> 00:24:34,000
+In this lesson, we learned the life cycle of the threat and how state of the threat is changed from
+
+357
+00:24:34,000 --> 00:24:36,000
+the new disseminated.
+
+358
+00:24:36,000 --> 00:24:39,000
+We learned five ways how to run a threat.
+
+359
+00:24:39,000 --> 00:24:43,000
+Also in this lesson, we performed over a year of threat class.
+
+360
+00:24:43,000 --> 00:24:48,000
+Now, you know, main properties of this type, we learned a radical interface.
+
+361
+00:24:48,000 --> 00:24:51,000
+Now you know how to use it to execute a separate threat.
+
+362
+00:24:52,000 --> 00:24:55,000
+And at the end of the lesson, we learned how to interrupt threat.
+
+363
+00:24:56,000 --> 00:24:59,000
+Hope you enjoyed the lesson and you like the examples.
+
+364
+00:24:59,000 --> 00:25:02,000
+We still have a lot of other things to learn, but.
+
+365
+00:25:02,000 --> 00:25:08,000
+I think that they will have enough information to remember, make sure you understand this lesson before
+
+366
+00:25:08,000 --> 00:25:12,000
+moving further, because multithreaded is not the easiest topic.
+
+367
+00:25:12,000 --> 00:25:18,000
+And we need to be very careful with understanding each concept in sequential order, because it would
+
+368
+00:25:18,000 --> 00:25:22,000
+be hard to understand one thing without understanding the previous one.
+
+369
+00:25:22,000 --> 00:25:23,000
+Thanks a lot for your attention.
+
+370
+00:25:24,000 --> 00:25:27,000
+Have a great day and see you in the next lesson.
+

27 - Multithreading/002 Source-code-of-the-First-multithreading-program.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/multithreading/FirstMultithreadingProgram.java

27 - Multithreading/002 Source-code-of-thread-interruption-demo.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/multithreading/InterruptDemo.java

27 - Multithreading/003 Source-code-of-the-Priority-demo.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/multithreading/PriorityDemo.java

27 - Multithreading/003 Source-code-of-the-Thread-group.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/multithreading/ThreadGroupDemo.java

27 - Multithreading/003 Source-code-of-the-daemon-threads.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/multithreading/DaemonThreadDemo.java

27 - Multithreading/003 Source-code-of-the-yield-method-demo.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/multithreading/YieldDemo.java

27 - Multithreading/003 Source-code-of-throwing-exception-from-run-method-example.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/blob/master/src/com/itbulls/learnit/javacore/multithreading/ThrowingExceptionFromRunnableDemo.java

27 - Multithreading/003 Thread Scheduler, Race Condition, Daemon Threads & Thread Groups_en.srt

@@ -0,0 +1,1128 @@
+1
+00:00:05,000 --> 00:00:10,000
+How came in this lesson, we're going to learn more about threats, the threats and threat groups,
+
+2
+00:00:11,000 --> 00:00:17,000
+basically that's what we have in our agenda for the day as we review these topics one by one, I will
+
+3
+00:00:17,000 --> 00:00:23,000
+also explain what's raised of condition is how priority works with threats and why do we need you to
+
+4
+00:00:23,000 --> 00:00:24,000
+MASSETT.
+
+5
+00:00:24,000 --> 00:00:29,000
+And also, at the end of this lesson, I will show you how we can throw an exception from the wrong
+
+6
+00:00:29,000 --> 00:00:30,000
+message.
+
+7
+00:00:30,000 --> 00:00:35,000
+And as always, we are going through different examples today that will help you to understand the topic
+
+8
+00:00:35,000 --> 00:00:36,000
+better.
+
+9
+00:00:36,000 --> 00:00:40,000
+All source code examples are in attachments to this lesson.
+
+10
+00:00:40,000 --> 00:00:41,000
+Let's start.
+
+11
+00:00:41,000 --> 00:00:44,000
+And the first thing that we are going to learn today is the threats.
+
+12
+00:00:44,000 --> 00:00:49,000
+Cédula in Paris, less than I already mentioned about threats Cédula and told you that this is part
+
+13
+00:00:49,000 --> 00:00:54,000
+of GM that decides which threats will be executed next and which threats should wait.
+
+14
+00:00:55,000 --> 00:01:00,000
+Also, I mentioned the threats CÉDULA, which is a threat that is in Runnable state.
+
+15
+00:01:00,000 --> 00:01:04,000
+That means the threat is running or waiting are blocked.
+
+16
+00:01:04,000 --> 00:01:10,000
+But imagine that you have multiple threats running right now and your computer doesn't have enough computing
+
+17
+00:01:10,000 --> 00:01:13,000
+capacity to start work on all threats at once.
+
+18
+00:01:14,000 --> 00:01:20,000
+So it's Canada will need to make a decision in such case, what threat to run first and which one should
+
+19
+00:01:20,000 --> 00:01:27,000
+go after was not an easy decision for a threat schedule, but how it would make a decision or what factors
+
+20
+00:01:27,000 --> 00:01:30,000
+will be part of the decision making process.
+
+21
+00:01:30,000 --> 00:01:32,000
+The first factor is priority.
+
+22
+00:01:32,000 --> 00:01:35,000
+The remember priority property from a threat class.
+
+23
+00:01:35,000 --> 00:01:42,000
+This is in the valley as it may be in range from one to ten is the high priority really should indicate
+
+24
+00:01:42,000 --> 00:01:49,000
+the threat that this threat should be prioritized over threats that have lower priority during the threat
+
+25
+00:01:49,000 --> 00:01:49,000
+of association.
+
+26
+00:01:50,000 --> 00:01:53,000
+New threat takes the same priority as parents threat.
+
+27
+00:01:54,000 --> 00:01:58,000
+Also, we have certain message that should help us to set new priorities if needed.
+
+28
+00:01:58,000 --> 00:01:59,000
+But what to do in this case?
+
+29
+00:01:59,000 --> 00:02:01,000
+Multiple threats have the same priority.
+
+30
+00:02:02,000 --> 00:02:06,000
+In this case, it is really hard to predict what would be the decision of threats.
+
+31
+00:02:06,000 --> 00:02:12,000
+Cédula that's why it is fair to make an assumption that random threat will be selected.
+
+32
+00:02:12,000 --> 00:02:19,000
+But we know that random is something human related only there is a programming code in place to make
+
+33
+00:02:19,000 --> 00:02:20,000
+a random decision.
+
+34
+00:02:20,000 --> 00:02:23,000
+We'll discuss this in the details later today.
+
+35
+00:02:23,000 --> 00:02:26,000
+And the second factor is in the arrival time.
+
+36
+00:02:26,000 --> 00:02:33,000
+Threats can also take into account the fact when threat arrived and how long each of them waited in
+
+37
+00:02:33,000 --> 00:02:36,000
+case with similar priority of threats.
+
+38
+00:02:36,000 --> 00:02:40,000
+Arrival time is one of the things that will be considered by threat schedule.
+
+39
+00:02:40,000 --> 00:02:44,000
+But again, this fact is not the final one in making the final decision.
+
+40
+00:02:45,000 --> 00:02:51,000
+So how the threats works, let's try to understand in a multi threat environment, multiple threats
+
+41
+00:02:51,000 --> 00:02:59,000
+executed concurrently, but processer allocates a small amount of time that is usually called time slice
+
+42
+00:02:59,000 --> 00:03:00,000
+through each threat.
+
+43
+00:03:01,000 --> 00:03:05,000
+So the task of threats CÉDULA is to verify each threat and make a decision.
+
+44
+00:03:06,000 --> 00:03:08,000
+What threat will get processers down first?
+
+45
+00:03:09,000 --> 00:03:13,000
+There is different scale algorithm used to answer this question.
+
+46
+00:03:13,000 --> 00:03:14,000
+Let's review them.
+
+47
+00:03:14,000 --> 00:03:16,000
+Preemptive priorities.
+
+48
+00:03:16,000 --> 00:03:20,000
+Keadilan this is algorithms that we partially discussed already.
+
+49
+00:03:20,000 --> 00:03:23,000
+Sweat's killer also at his highest priority.
+
+50
+00:03:24,000 --> 00:03:26,000
+The rest of the threats will be ignored.
+
+51
+00:03:26,000 --> 00:03:30,000
+But in this case, is it possible at all for other threats to be executed?
+
+52
+00:03:31,000 --> 00:03:31,000
+Yes.
+
+53
+00:03:32,000 --> 00:03:38,000
+In case as a threat has high priority or current threat, went to Washington state or was interrupted
+
+54
+00:03:38,000 --> 00:03:42,000
+or with the help of field marshal, what is yield massive?
+
+55
+00:03:42,000 --> 00:03:48,000
+This is akin to the scale of the current threat is willing to yield its current use of process and execution
+
+56
+00:03:48,000 --> 00:03:49,000
+time.
+
+57
+00:03:49,000 --> 00:03:52,000
+But the scandal is free to ignore this.
+
+58
+00:03:52,000 --> 00:03:57,000
+But to be honest regarding this particular matter, it is really appropriate to use it.
+
+59
+00:03:57,000 --> 00:04:00,000
+It may be usable for the bargain for testing purposes.
+
+60
+00:04:00,000 --> 00:04:07,000
+With my help to reproduce the race condition, we'll talk about what race condition is a little bit
+
+61
+00:04:07,000 --> 00:04:08,000
+later in this lesson.
+
+62
+00:04:08,000 --> 00:04:11,000
+The next algorithm is first come, first serve.
+
+63
+00:04:11,000 --> 00:04:13,000
+Scheduling rules are simple here.
+
+64
+00:04:14,000 --> 00:04:20,000
+Zaretsky assigns CPU time to the threads that appear to be the one who requested it first.
+
+65
+00:04:21,000 --> 00:04:23,000
+Also, we shouldn't forget about slice and schedule.
+
+66
+00:04:24,000 --> 00:04:28,000
+You already understood that piece of time for each thread is called a time slice.
+
+67
+00:04:28,000 --> 00:04:35,000
+Each thread gets executed cyclically one after another as Reskin will track where the threads finished.
+
+68
+00:04:35,000 --> 00:04:38,000
+His execution was in a time slice or no in case.
+
+69
+00:04:38,000 --> 00:04:43,000
+Yes, this threat will be removed from CU and Schoettler will work with other threats.
+
+70
+00:04:43,000 --> 00:04:45,000
+Only is it clear.
+
+71
+00:04:46,000 --> 00:04:50,000
+Now let's check how all these algorithms work together on the simple example.
+
+72
+00:04:51,000 --> 00:04:54,000
+Imagine that we have five threads and only one processor.
+
+73
+00:04:55,000 --> 00:04:59,000
+Let's make an assumption that all threats have different priorities and different arrival time.
+
+74
+00:05:00,000 --> 00:05:01,000
+The together that uses.
+
+75
+00:05:02,000 --> 00:05:07,000
+Algorithms that we have discussed, it will decide which thread to select to give a time of crisis.
+
+76
+00:05:08,000 --> 00:05:14,000
+At first, Zaretsky should select the highest priority and in case of a threat, was high priority with
+
+77
+00:05:14,000 --> 00:05:16,000
+request access to processer.
+
+78
+00:05:17,000 --> 00:05:24,000
+Then you will get access to the CPU during the first opportunity and once will deal with the same priority
+
+79
+00:05:24,000 --> 00:05:28,000
+Skidder will use first come first serve scale algorithms to those threats.
+
+80
+00:05:29,000 --> 00:05:33,000
+So hope now you have the vision how threats are executed in the current environment.
+
+81
+00:05:34,000 --> 00:05:40,000
+Now let me quickly explain what is the condition then, multiple definitions of this term.
+
+82
+00:05:41,000 --> 00:05:46,000
+Let me share with you, some of them in some sort of serious condition is explained like I can issue
+
+83
+00:05:46,000 --> 00:05:53,000
+an error in multistorey and program design when program execution depends on the sequence of Seurat's
+
+84
+00:05:53,000 --> 00:05:54,000
+execution.
+
+85
+00:05:54,000 --> 00:06:00,000
+The error guernseys name from the similar mistake in electronic circuit design signals race.
+
+86
+00:06:01,000 --> 00:06:07,000
+And as a leader, you may find definitions of race condition as not an issue, but as a state of the
+
+87
+00:06:07,000 --> 00:06:14,000
+system where substantive behavior of an application is dependent on the sequence or of other events.
+
+88
+00:06:15,000 --> 00:06:20,000
+So is it an issue or just a state without any consequences and without any impact?
+
+89
+00:06:21,000 --> 00:06:25,000
+Actually, race condition may cause various impact on your execution.
+
+90
+00:06:26,000 --> 00:06:27,000
+Let's review some of them.
+
+91
+00:06:27,000 --> 00:06:34,000
+Memory leak and controlled access to the common memory during the race condition, mainly due to having
+
+92
+00:06:34,000 --> 00:06:35,000
+memory leak.
+
+93
+00:06:35,000 --> 00:06:39,000
+It can visit memory that is needed is not released by some thread.
+
+94
+00:06:39,000 --> 00:06:42,000
+For example, inconsistent data.
+
+95
+00:06:42,000 --> 00:06:48,000
+It may happen that both threads managed to get access to the same resource and one of the mistakes of
+
+96
+00:06:48,000 --> 00:06:50,000
+concurrent interaction happened.
+
+97
+00:06:50,000 --> 00:06:56,000
+Probably one thread of data to resource was one value, but another threat overrides its value with
+
+98
+00:06:56,000 --> 00:06:56,000
+new one.
+
+99
+00:06:57,000 --> 00:07:02,000
+And you have lost update or for example, once to use a resource to read data from it.
+
+100
+00:07:02,000 --> 00:07:08,000
+But in the meantime, in parallel as a threat, updating this resource and the first resource with our
+
+101
+00:07:08,000 --> 00:07:10,000
+data data, this is called virtual.
+
+102
+00:07:11,000 --> 00:07:13,000
+It is also possible to face other issues.
+
+103
+00:07:14,000 --> 00:07:18,000
+But I believe you understand the potential impact for data consistency in your app.
+
+104
+00:07:19,000 --> 00:07:22,000
+Dedlock and liveblog is a separate lesson.
+
+105
+00:07:22,000 --> 00:07:25,000
+I will show you examples of Dedlock and liveblog.
+
+106
+00:07:25,000 --> 00:07:30,000
+Ensure this situation in your app decreased productivity of each threat to zero.
+
+107
+00:07:31,000 --> 00:07:32,000
+Is that technically working?
+
+108
+00:07:32,000 --> 00:07:38,000
+But they don't produce any results and also there might be other impacts caused by race conditions.
+
+109
+00:07:39,000 --> 00:07:43,000
+So these are just a few potential impacts that you may face with Ingres.
+
+110
+00:07:43,000 --> 00:07:46,000
+Conditions state how to avoid race condition.
+
+111
+00:07:47,000 --> 00:07:53,000
+We can avoid risk conditions by building proper synchronization in critical sections of execution.
+
+112
+00:07:53,000 --> 00:07:59,000
+DigiCam provides different ways for stress synchronization, and we'll run them in a separate lessons.
+
+113
+00:07:59,000 --> 00:08:02,000
+We learned a lot of new things for the day.
+
+114
+00:08:02,000 --> 00:08:07,000
+Let's start practical part of our lesson and review the source code of our examples.
+
+115
+00:08:07,000 --> 00:08:09,000
+Let's start from priority to demo.
+
+116
+00:08:09,000 --> 00:08:15,000
+I was shown now that you know I should count on property property as we discussed.
+
+117
+00:08:15,000 --> 00:08:20,000
+Yes, it will be considered, but take into account that might be different cases.
+
+118
+00:08:21,000 --> 00:08:25,000
+When threat arrived and ready for execution, one processor time is available.
+
+119
+00:08:25,000 --> 00:08:32,000
+The greatest threat and one processor ready to process said a lot of things happen literally in milliseconds.
+
+120
+00:08:32,000 --> 00:08:35,000
+I have files, as is called priority demo.
+
+121
+00:08:35,000 --> 00:08:36,000
+What do we have here?
+
+122
+00:08:37,000 --> 00:08:39,000
+We have static MassArt with name executes it.
+
+123
+00:08:39,000 --> 00:08:44,000
+I will use to create objects of a threat that this is a similar method, the one we had in previous
+
+124
+00:08:44,000 --> 00:08:45,000
+demo.
+
+125
+00:08:45,000 --> 00:08:48,000
+I just bring the name of the threat to console.
+
+126
+00:08:48,000 --> 00:08:53,000
+I create five threats and pay attention to the naming convention of the variables.
+
+127
+00:08:53,000 --> 00:08:55,000
+I'm starting indexing from zero.
+
+128
+00:08:56,000 --> 00:09:00,000
+This will help us to match variable name and threatening and cancel.
+
+129
+00:09:00,000 --> 00:09:04,000
+I use certain method to set different priorities, can use threats.
+
+130
+00:09:04,000 --> 00:09:07,000
+You can see the threat zero has the lowest priority.
+
+131
+00:09:07,000 --> 00:09:13,000
+So I want to have the highest priority and the rest of threats also have different priorities here.
+
+132
+00:09:14,000 --> 00:09:20,000
+Also, you need to know that threat clause has different constants already to separate the three constants.
+
+133
+00:09:20,000 --> 00:09:27,000
+The main priority that is equal to one naum priority is equal to five and max priorities.
+
+134
+00:09:27,000 --> 00:09:28,000
+That is equal to that.
+
+135
+00:09:29,000 --> 00:09:32,000
+You can use this constant in setting masses if you want.
+
+136
+00:09:32,000 --> 00:09:39,000
+And after all these configurations, I run my app, I will run it multiple times, try to pay attention
+
+137
+00:09:39,000 --> 00:09:43,000
+to what stories will be printed to console first and what will be printed last.
+
+138
+00:09:44,000 --> 00:09:50,000
+And you can see that in most cases read no one is printed most of the times to console in the first
+
+139
+00:09:50,000 --> 00:09:50,000
+row.
+
+140
+00:09:50,000 --> 00:09:56,000
+And the strange thing is that a threat to that is also brought it then maybe printed the last one.
+
+141
+00:09:57,000 --> 00:09:59,000
+So something strange is happening here.
+
+142
+00:09:59,000 --> 00:10:00,000
+Threads it has.
+
+143
+00:10:00,000 --> 00:10:05,000
+Highest priority and not the last arrival time will be painted the last one.
+
+144
+00:10:06,000 --> 00:10:08,000
+Why was the magic is happening here?
+
+145
+00:10:09,000 --> 00:10:10,000
+You're right.
+
+146
+00:10:10,000 --> 00:10:12,000
+This is magic of concurrent execution.
+
+147
+00:10:12,000 --> 00:10:18,000
+Imagine that you have multiple tasks at once, great threads, running threads, synchronized access
+
+148
+00:10:18,000 --> 00:10:19,000
+to the Queensland method.
+
+149
+00:10:20,000 --> 00:10:21,000
+And we'll get to synchronization soon.
+
+150
+00:10:22,000 --> 00:10:28,000
+And you will learn that Sprint alone is synchronized and time slices for each thread are not infinite.
+
+151
+00:10:28,000 --> 00:10:35,000
+And while a lot of things happen, not always our brains can understand why we see this result, but
+
+152
+00:10:35,000 --> 00:10:36,000
+not the last one.
+
+153
+00:10:37,000 --> 00:10:38,000
+But at least my brain for sure.
+
+154
+00:10:38,000 --> 00:10:40,000
+Not always can understand this.
+
+155
+00:10:40,000 --> 00:10:45,000
+But anyway, this is what you should know about MultiThreaded before you start creating lots of training
+
+156
+00:10:45,000 --> 00:10:46,000
+programs.
+
+157
+00:10:46,000 --> 00:10:50,000
+You can't always predict the sequence of execution.
+
+158
+00:10:50,000 --> 00:10:51,000
+That's why.
+
+159
+00:10:51,000 --> 00:10:51,000
+Will it always?
+
+160
+00:10:51,000 --> 00:10:58,000
+You have to create programs that will not depend on the sequence of execution with race condition and
+
+161
+00:10:58,000 --> 00:11:01,000
+unexpected impact on the results of our application.
+
+162
+00:11:02,000 --> 00:11:07,000
+Now, when I show you that you shouldn't completely rely on priority property, let me also show you
+
+163
+00:11:07,000 --> 00:11:08,000
+another thing.
+
+164
+00:11:08,000 --> 00:11:11,000
+This time I'll show you the massive example.
+
+165
+00:11:11,000 --> 00:11:13,000
+We have two threats.
+
+166
+00:11:13,000 --> 00:11:19,000
+The first threat gives a hint of threats, cédula that the threat is ready to yield its current use
+
+167
+00:11:19,000 --> 00:11:22,000
+of a processor and after that freeze its name.
+
+168
+00:11:23,000 --> 00:11:26,000
+The second threat, Princetonian of the threat straight away.
+
+169
+00:11:27,000 --> 00:11:28,000
+I believe this is clear.
+
+170
+00:11:28,000 --> 00:11:34,000
+Let's execute our app multiple times and we can see that output is not deterministic.
+
+171
+00:11:35,000 --> 00:11:39,000
+Sometimes zero is printed to console first and sometimes otherwise.
+
+172
+00:11:40,000 --> 00:11:44,000
+It looks like it doesn't make a lot of sense whether I'm using static method.
+
+173
+00:11:44,000 --> 00:11:51,000
+You know, we can even make an assumption that access to such a centralized method as printer land is
+
+174
+00:11:51,000 --> 00:11:55,000
+random no matter what they use method or no.
+
+175
+00:11:55,000 --> 00:12:00,000
+That's why in documentation, it's clearly written that threats cannot ignore this hint.
+
+176
+00:12:01,000 --> 00:12:08,000
+And all my life I ask different people multiple times the question why isn't we need to yield massive
+
+177
+00:12:08,000 --> 00:12:09,000
+and broad use?
+
+178
+00:12:09,000 --> 00:12:13,000
+They don't bring us to the same expected result every time.
+
+179
+00:12:13,000 --> 00:12:19,000
+And I been answered, like I explained to you, different algorithms, time slicing, and probably even
+
+180
+00:12:19,000 --> 00:12:20,000
+the business world can yield massive.
+
+181
+00:12:21,000 --> 00:12:24,000
+The chances are different to execute one or another threat.
+
+182
+00:12:24,000 --> 00:12:31,000
+But in real life and in Damos cases, it is almost impossible to visualize the benefit of this methods.
+
+183
+00:12:31,000 --> 00:12:36,000
+Unfortunately, that is something that you should know about Lucas writing in Paris last month when
+
+184
+00:12:36,000 --> 00:12:43,000
+we performed an overview of a threat glass and I promised you to explain what demon threats are actually
+
+185
+00:12:43,000 --> 00:12:45,000
+are not so much things to here.
+
+186
+00:12:46,000 --> 00:12:48,000
+Jim is stopped once.
+
+187
+00:12:48,000 --> 00:12:50,000
+There are only demons, rats running.
+
+188
+00:12:50,000 --> 00:12:56,000
+This is very useful to great demon threats, like supporters of another threat, for example, in case
+
+189
+00:12:56,000 --> 00:13:03,000
+when demons can't exist without us a threat because it's not so important without another threat.
+
+190
+00:13:03,000 --> 00:13:10,000
+In one of home tasks, I would ask you to create demon threats that will recent events in another thread.
+
+191
+00:13:10,000 --> 00:13:12,000
+And in the case there is known as a threat.
+
+192
+00:13:12,000 --> 00:13:14,000
+There is nothing to listen.
+
+193
+00:13:14,000 --> 00:13:16,000
+I know from demons, threats, demon class.
+
+194
+00:13:17,000 --> 00:13:22,000
+I create a thread that contains infinite loop and brings the demon is in each half of the second.
+
+195
+00:13:23,000 --> 00:13:30,000
+I start the thread and make my mind sweat sleep for two seconds and after that I pray that the main
+
+196
+00:13:30,000 --> 00:13:31,000
+threat is finished.
+
+197
+00:13:31,000 --> 00:13:34,000
+I will keep this land commanded for the first round.
+
+198
+00:13:35,000 --> 00:13:41,000
+I run the program and as you can see, even after two seconds and even after my strength was finished
+
+199
+00:13:41,000 --> 00:13:48,000
+and Nasrat is still working, the only way for me to stop it now is to stop Jaba process.
+
+200
+00:13:49,000 --> 00:13:50,000
+I press the stop sign here.
+
+201
+00:13:51,000 --> 00:13:53,000
+Let's do another thing now.
+
+202
+00:13:53,000 --> 00:13:54,000
+I have a lot in common.
+
+203
+00:13:54,000 --> 00:14:03,000
+This line I call set a massive here and set jemal flat to true now key once thread is demon and will
+
+204
+00:14:03,000 --> 00:14:05,000
+be stopped right after the threat is created.
+
+205
+00:14:05,000 --> 00:14:10,000
+It will be finished because after the threats have created it will be finished.
+
+206
+00:14:10,000 --> 00:14:12,000
+Only demons wrath will stay.
+
+207
+00:14:12,000 --> 00:14:20,000
+And considering the fact that one of the demon threats you will stop execution the generals or machine
+
+208
+00:14:20,000 --> 00:14:25,000
+exits and stop execution when the only threats is running at all demon threats.
+
+209
+00:14:25,000 --> 00:14:30,000
+Let's run our app now and we can see that once main threat is finished.
+
+210
+00:14:30,000 --> 00:14:32,000
+Jimmy, I am a stop.
+
+211
+00:14:32,000 --> 00:14:37,000
+Is it clear hope that this example helped you to understand what demons rates are?
+
+212
+00:14:38,000 --> 00:14:42,000
+Also, in previous lesson I promised to show you how to work with different groups.
+
+213
+00:14:43,000 --> 00:14:43,000
+In this lesson.
+
+214
+00:14:43,000 --> 00:14:46,000
+I also prepare them file to share it with you.
+
+215
+00:14:46,000 --> 00:14:48,000
+Let me remind you what social group?
+
+216
+00:14:48,000 --> 00:14:51,000
+S Support group is a set of threats.
+
+217
+00:14:51,000 --> 00:14:57,000
+The threat group forms that we in which every group except the initial threat group has apparent its
+
+218
+00:14:57,000 --> 00:15:00,000
+threat is allowed to access information about.
+
+219
+00:15:00,000 --> 00:15:06,000
+Its own strength group, but not the access information about its groups, parents or the group or any
+
+220
+00:15:06,000 --> 00:15:11,000
+other group, this that helps us to manage a group of threats as a single unit.
+
+221
+00:15:11,000 --> 00:15:17,000
+This is extremely valuable when you want to perform such operations as interrupt, for example, for
+
+222
+00:15:17,000 --> 00:15:19,000
+all threats, I will not lie to you.
+
+223
+00:15:19,000 --> 00:15:22,000
+And I'm going to say that this type is not very popular today.
+
+224
+00:15:23,000 --> 00:15:28,000
+In this search code, you can find and mentions a certain group is pretty old type that was created
+
+225
+00:15:28,000 --> 00:15:30,000
+in Java version one.
+
+226
+00:15:30,000 --> 00:15:36,000
+That's why I don't see a lot of sense to go over each message here and show you an example for each
+
+227
+00:15:36,000 --> 00:15:41,000
+Massett, because it is very less likely that you will use this class in production.
+
+228
+00:15:41,000 --> 00:15:47,000
+But still, I believe it was me sharing it with you for general educational purposes, at least on the
+
+229
+00:15:47,000 --> 00:15:52,000
+high level, because programming languages is constantly improved and new types are introduced.
+
+230
+00:15:53,000 --> 00:15:59,000
+But core principles are the same and understand in such basics as this class will help you to grasp
+
+231
+00:15:59,000 --> 00:16:00,000
+new knowledge faster.
+
+232
+00:16:01,000 --> 00:16:02,000
+I open them a file.
+
+233
+00:16:03,000 --> 00:16:10,000
+The first things that I do in this example, Ikarus object basically very different constructors.
+
+234
+00:16:10,000 --> 00:16:15,000
+You can create a group with name or person as interest groups are supposed to be a parent for the new
+
+235
+00:16:15,000 --> 00:16:15,000
+one.
+
+236
+00:16:16,000 --> 00:16:22,000
+And then after that I create multiple threats and possible reference to the third group in constructor.
+
+237
+00:16:22,000 --> 00:16:28,000
+Also, I incommensurable interface by persons, a reference to the execute method so each threat will
+
+238
+00:16:28,000 --> 00:16:31,000
+have infinite loop and it will print its name.
+
+239
+00:16:31,000 --> 00:16:37,000
+Each half of the second and once read will be interrupted while sleeping will break the loop.
+
+240
+00:16:37,000 --> 00:16:38,000
+In main method.
+
+241
+00:16:38,000 --> 00:16:45,000
+I start all threads and make my main thread sleep for two seconds and after that I don't need to interrupt
+
+242
+00:16:45,000 --> 00:16:46,000
+each thread separately.
+
+243
+00:16:47,000 --> 00:16:54,000
+But instead I look into wrapped method on a select group and I expect all threads in this group will
+
+244
+00:16:54,000 --> 00:16:54,000
+be interrupted.
+
+245
+00:16:55,000 --> 00:16:59,000
+Let's run this program and see what we have and the result is expected.
+
+246
+00:17:00,000 --> 00:17:04,000
+We interrupted all threads and broke infinite loop jam is stopped.
+
+247
+00:17:05,000 --> 00:17:11,000
+This is how easily I can interact with a group of threads with the help of threads, group type and
+
+248
+00:17:11,000 --> 00:17:16,000
+the last bit on the list sink for this lesson that I wanted to share with you is how to throw exceptions
+
+249
+00:17:16,000 --> 00:17:17,000
+from the Runnable.
+
+250
+00:17:17,000 --> 00:17:23,000
+If you remember, one method in Runnable interface doesn't declare that it makes any exception.
+
+251
+00:17:24,000 --> 00:17:29,000
+This is exactly the reason why we should handle all checked exceptions inside are unnecessary.
+
+252
+00:17:29,000 --> 00:17:35,000
+But what if you don't know how to handle specific exception and you need to throw the exception according
+
+253
+00:17:35,000 --> 00:17:37,000
+to a logic, how to be in this case?
+
+254
+00:17:38,000 --> 00:17:42,000
+There is a dirty trick that you can do if needed to throw exceptions from the run.
+
+255
+00:17:43,000 --> 00:17:44,000
+Pay attention.
+
+256
+00:17:44,000 --> 00:17:46,000
+You can't leave without handloom.
+
+257
+00:17:46,000 --> 00:17:51,000
+Check the exceptions, but nobody set any restrictions on unchecked exceptions.
+
+258
+00:17:52,000 --> 00:17:53,000
+They understand what I mean.
+
+259
+00:17:53,000 --> 00:17:58,000
+We'll wrap our checked exception in and check in our example.
+
+260
+00:17:58,000 --> 00:18:03,000
+You can see how I tried to imitate IO exception by putting illegal pasta sauce.
+
+261
+00:18:03,000 --> 00:18:06,000
+I catch the exception and throw a new one.
+
+262
+00:18:06,000 --> 00:18:13,000
+This time I throw runtime exception and I pass an exception to a constructor like a course of the exception.
+
+263
+00:18:13,000 --> 00:18:16,000
+Let's execute this thread and see what we have.
+
+264
+00:18:16,000 --> 00:18:17,000
+Great.
+
+265
+00:18:17,000 --> 00:18:23,000
+You have runtime exception which caused by no such file exception and now you're Lowgar will be able
+
+266
+00:18:23,000 --> 00:18:30,000
+to grab this looks to the proper and actual issues that will help you during investigation and debugging
+
+267
+00:18:30,000 --> 00:18:31,000
+in the future.
+
+268
+00:18:32,000 --> 00:18:36,000
+The information about those exceptional will help you to understand the reason of threat interruption.
+
+269
+00:18:37,000 --> 00:18:40,000
+That's all what I wanted to share with you in this lesson.
+
+270
+00:18:40,000 --> 00:18:43,000
+Let's recap what we have learned in this lesson.
+
+271
+00:18:44,000 --> 00:18:45,000
+Is this lesson learned?
+
+272
+00:18:45,000 --> 00:18:48,000
+What is a threat scandal and how it works now?
+
+273
+00:18:48,000 --> 00:18:54,000
+You know what race condition is and what potential impact it can bring in this course, we'll learn
+
+274
+00:18:54,000 --> 00:18:56,000
+how to deal with race condition.
+
+275
+00:18:56,000 --> 00:19:02,000
+Also, I showed you an example of how property property impacts and the threat and execution and how
+
+276
+00:19:02,000 --> 00:19:04,000
+your message works.
+
+277
+00:19:04,000 --> 00:19:10,000
+We learned what the threats are and examples I showed you how you can manipulate a group of threats
+
+278
+00:19:10,000 --> 00:19:11,000
+with a group object.
+
+279
+00:19:12,000 --> 00:19:16,000
+And at the end of the lesson, I show you how we can throw exemption from randomness.
+
+280
+00:19:17,000 --> 00:19:18,000
+That's it for this lesson.
+
+281
+00:19:18,000 --> 00:19:20,000
+Thanks a lot for your attention.
+
+282
+00:19:20,000 --> 00:19:23,000
+Have a great day and see you in the next lesson.
+

27 - Multithreading/004 Source-code-of-all-examples-from-the-lesson.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL=https://github.com/AndriiPiatakha/learnit_java_core/tree/master/src/com/itbulls/learnit/javacore/multithreading/waitnotify

27 - Multithreading/004 Synchronization Basics_en.srt

@@ -0,0 +1,1532 @@
+1
+00:00:05,000 --> 00:00:09,000
+How are the students in this lesson, we are going to learn the basics of synchronization.
+
+2
+00:00:10,000 --> 00:00:14,000
+Synchronization is a huge topic and we'll learn it with you during multiple lessons.
+
+3
+00:00:15,000 --> 00:00:20,000
+This is the first lesson about stress and presentations that will give you basic knowledge when you
+
+4
+00:00:20,000 --> 00:00:22,000
+create concurrent programs.
+
+5
+00:00:22,000 --> 00:00:28,000
+One of the most important things that you should care about is a synchronized access of multiple threats
+
+6
+00:00:28,000 --> 00:00:29,000
+to the critical errors.
+
+7
+00:00:30,000 --> 00:00:36,000
+What is critical sections will learn with you today in this lesson also will learn with your concepts
+
+8
+00:00:36,000 --> 00:00:37,000
+of monitor and mutex.
+
+9
+00:00:38,000 --> 00:00:43,000
+After this lesson, you will understand these two concepts where, well, I will explain to you what
+
+10
+00:00:43,000 --> 00:00:46,000
+is at tormey cooperation and what is not.
+
+11
+00:00:46,000 --> 00:00:53,000
+Once you understand, all this theory will jump to practical examples and will create our first program
+
+12
+00:00:53,000 --> 00:00:54,000
+with synchronized threats.
+
+13
+00:00:54,000 --> 00:01:00,000
+I will explain how a synchronized keyboard works with Marcedes, and at the end of the lesson I will
+
+14
+00:01:00,000 --> 00:01:04,000
+explain such methods as a way to notify and notify all.
+
+15
+00:01:04,000 --> 00:01:07,000
+All objects in Java have these methods.
+
+16
+00:01:07,000 --> 00:01:09,000
+Let's start to begin with.
+
+17
+00:01:09,000 --> 00:01:12,000
+Let's understand what a critical section is.
+
+18
+00:01:12,000 --> 00:01:18,000
+It is important for us to learn this first because the rest of what we are going to do in this lesson
+
+19
+00:01:18,000 --> 00:01:21,000
+is to synchronize access to critical sections.
+
+20
+00:01:21,000 --> 00:01:25,000
+That's why understanding of this term is critically important.
+
+21
+00:01:25,000 --> 00:01:32,000
+Imagine that you have multiple threats that are executed concurrently and there is block of code that
+
+22
+00:01:32,000 --> 00:01:36,000
+theoretically may be available simultaneously for two threats.
+
+23
+00:01:36,000 --> 00:01:43,000
+This means that in some point of time it might happen that two or more threats will interact with some
+
+24
+00:01:43,000 --> 00:01:49,000
+resource simultaneously that may cause mistakes in calculations and data.
+
+25
+00:01:49,000 --> 00:01:50,000
+Inconsistency.
+
+26
+00:01:50,000 --> 00:01:57,000
+In other words, critical section is a group of instructions that should be executed concurrently only
+
+27
+00:01:57,000 --> 00:02:01,000
+by a specific number of threats and performance specific operations.
+
+28
+00:02:01,000 --> 00:02:08,000
+Usually it is one threat, but as we keep learning to read into advanced level, you would understand
+
+29
+00:02:08,000 --> 00:02:11,000
+that sometimes we want to allow multiple threats to perform.
+
+30
+00:02:11,000 --> 00:02:16,000
+One operation was a resource and allow multiple threats to perform another operation.
+
+31
+00:02:16,000 --> 00:02:22,000
+For example, imagine that you have collection, let's say a list operation of the new elements, or
+
+32
+00:02:22,000 --> 00:02:25,000
+at least should not allow other threats.
+
+33
+00:02:25,000 --> 00:02:32,000
+Read value from any index at mass should block access for all of the threats to read elements from specific
+
+34
+00:02:32,000 --> 00:02:38,000
+index, because I can add new element in that position and that would cause there to be read by other
+
+35
+00:02:38,000 --> 00:02:39,000
+threats.
+
+36
+00:02:39,000 --> 00:02:46,000
+At the same time, there is no need to look at the threats in case all threats only read data from my
+
+37
+00:02:46,000 --> 00:02:49,000
+array list and don't change its state.
+
+38
+00:02:50,000 --> 00:02:57,000
+That's why I may allow as many threats as there exist to read data from our own list only until the
+
+39
+00:02:57,000 --> 00:03:01,000
+moment of adding new elements to contain that will count does it make sense.
+
+40
+00:03:02,000 --> 00:03:05,000
+Now let's understand what is an atomic operation.
+
+41
+00:03:05,000 --> 00:03:07,000
+Atomic comes from Greek word atom.
+
+42
+00:03:08,000 --> 00:03:12,000
+That literally means uncuttable in computer science.
+
+43
+00:03:12,000 --> 00:03:17,000
+Atomic operation is operations that is performed with single processing cycle.
+
+44
+00:03:17,000 --> 00:03:21,000
+In other words, atomic operation is an interrupted operation.
+
+45
+00:03:22,000 --> 00:03:23,000
+Let's understand this, an example.
+
+46
+00:03:24,000 --> 00:03:29,000
+Imagine that you perform an increment of your object's property and you want to update its state.
+
+47
+00:03:30,000 --> 00:03:34,000
+What this thing is, this atomic operation, it is not.
+
+48
+00:03:34,000 --> 00:03:35,000
+Why?
+
+49
+00:03:35,000 --> 00:03:40,000
+Because you have to read values that are stored in the piece of memory dictated to the class property
+
+50
+00:03:40,000 --> 00:03:41,000
+variable first.
+
+51
+00:03:42,000 --> 00:03:46,000
+After that you need to perform an increment and add one.
+
+52
+00:03:46,000 --> 00:03:51,000
+After that, you need to store the result of additions in some place, and only after that you need
+
+53
+00:03:51,000 --> 00:03:55,000
+to assign the result of increments to another variable.
+
+54
+00:03:55,000 --> 00:03:57,000
+Our class property is that clear.
+
+55
+00:03:58,000 --> 00:04:04,000
+So even such simple operation is the first glance like increment is not atomic, but in this case,
+
+56
+00:04:05,000 --> 00:04:07,000
+what is an atomic operation?
+
+57
+00:04:07,000 --> 00:04:09,000
+And simple words read and write.
+
+58
+00:04:09,000 --> 00:04:11,000
+Operations are atomic.
+
+59
+00:04:11,000 --> 00:04:18,000
+For example, assigning value to a variable is atomic operation removal value from array is atomic operation.
+
+60
+00:04:18,000 --> 00:04:21,000
+Assigning value is an atomic operation too.
+
+61
+00:04:22,000 --> 00:04:29,000
+Does it make sense also in general with a special package that contains only Tibs that execute not atomic
+
+62
+00:04:29,000 --> 00:04:35,000
+operations by nature, but actually execute operations that looks like atomic, for example?
+
+63
+00:04:36,000 --> 00:04:41,000
+You know, that increment and addition is not atomic operation by itself, but atomic integer, for
+
+64
+00:04:41,000 --> 00:04:48,000
+example, maybe from addition of another in synchronized manner to not allow any other threat interrupt
+
+65
+00:04:48,000 --> 00:04:55,000
+execution of the separation later in this course, will review is generally two concurrent atomic package
+
+66
+00:04:55,000 --> 00:04:58,000
+that contains such types of perform atomic operations.
+
+67
+00:04:59,000 --> 00:05:03,000
+Would it a great single ready now you know what is an atomic.
+
+68
+00:05:03,000 --> 00:05:07,000
+Atomic operations also know what a critical section is.
+
+69
+00:05:07,000 --> 00:05:12,000
+Let's look at example now so that you can understand the problem of performing non atomic operations
+
+70
+00:05:12,000 --> 00:05:19,000
+with multiple threats and why we need to synchronize access to critical section I open unsynchronized
+
+71
+00:05:19,000 --> 00:05:20,000
+incremented file.
+
+72
+00:05:20,000 --> 00:05:22,000
+Let's look at the main message here.
+
+73
+00:05:22,000 --> 00:05:29,000
+And I will say you before we start that the quote below is a spaghetti code because we don't use executer
+
+74
+00:05:29,000 --> 00:05:34,000
+in this example, considering the fact that by this moment in our course, we don't know.
+
+75
+00:05:34,000 --> 00:05:40,000
+Executor's, I will show you this example was BASIX, Red Cross and Runnable interface that we all know
+
+76
+00:05:41,000 --> 00:05:46,000
+later in this course, we'll show you another solution, which is, in my opinion, more elegant.
+
+77
+00:05:46,000 --> 00:05:53,000
+But I will show it to you once we execute our stoppered hacker, at least that will contain references
+
+78
+00:05:53,000 --> 00:06:00,000
+to ohmy threat objects, because I'm going to create 10000 thread objects when it's so many threads
+
+79
+00:06:00,000 --> 00:06:07,000
+objects to be able to demo issues that may happen in case with performing on atomic operation with multiple
+
+80
+00:06:07,000 --> 00:06:09,000
+threats have falu.
+
+81
+00:06:09,000 --> 00:06:11,000
+And you can see that in condition.
+
+82
+00:06:11,000 --> 00:06:16,000
+I verify that I made 10000 iterations on each iteration.
+
+83
+00:06:16,000 --> 00:06:21,000
+I create a new threat object with the following implementation of Runnable interface.
+
+84
+00:06:21,000 --> 00:06:27,000
+I increment my static int variables that is present in this class and I will perform this increment
+
+85
+00:06:27,000 --> 00:06:29,000
+10000 times.
+
+86
+00:06:29,000 --> 00:06:37,000
+So what value will be here once all threats will perform increment ten thousand times will look at the
+
+87
+00:06:37,000 --> 00:06:43,000
+answer in the minutes after that and look at reference of this threat to the common list of threats.
+
+88
+00:06:43,000 --> 00:06:50,000
+I need this to be able to request each threat to join main threat and make main threat, wait until
+
+89
+00:06:50,000 --> 00:06:52,000
+all other threats will be executed.
+
+90
+00:06:53,000 --> 00:07:00,000
+And again, you need to see this code to feel relief later when you will start to use executer, because
+
+91
+00:07:00,000 --> 00:07:05,000
+you will understand how executables would simplify interaction with multiple threats.
+
+92
+00:07:05,000 --> 00:07:09,000
+And in Body of the Loop, I start each threat after that.
+
+93
+00:07:09,000 --> 00:07:14,000
+And for each loop I ask each threat, the join main threat and make my main threat.
+
+94
+00:07:14,000 --> 00:07:18,000
+Wait until all other threats will be executed.
+
+95
+00:07:18,000 --> 00:07:24,000
+When all threats did incremented, we can print our variable to cancel and let's see.
+
+96
+00:07:24,000 --> 00:07:28,000
+Instead I will run program multiple times to let you see the issue.
+
+97
+00:07:29,000 --> 00:07:32,000
+Can you see that the result is not always 10000?
+
+98
+00:07:33,000 --> 00:07:35,000
+They understand why this is happening.
+
+99
+00:07:36,000 --> 00:07:43,000
+That is because at some moment of time, two threats enter this method simultaneously and both threats
+
+100
+00:07:43,000 --> 00:07:48,000
+read the same value of counter variable and each threat might increment.
+
+101
+00:07:48,000 --> 00:07:51,000
+But logically, this is two increments.
+
+102
+00:07:51,000 --> 00:07:58,000
+But in fact, once we get our right increment result from as a threat and we got lost update, is it
+
+103
+00:07:58,000 --> 00:08:02,000
+clear now and what to do and how to solve this issue?
+
+104
+00:08:02,000 --> 00:08:05,000
+You already can easily spot where critical section is.
+
+105
+00:08:06,000 --> 00:08:12,000
+We need to synchronize access of different threats to our critical section where we are careful not
+
+106
+00:08:12,000 --> 00:08:13,000
+optronics operation.
+
+107
+00:08:14,000 --> 00:08:20,000
+That's why I started the lesson from explanation of critical sections and atomic operations to make
+
+108
+00:08:20,000 --> 00:08:25,000
+sure that by this moment of time in our lesson, you would understand what I'm talking about.
+
+109
+00:08:25,000 --> 00:08:28,000
+Let's now try to solve this issue.
+
+110
+00:08:28,000 --> 00:08:35,000
+To solve this issue, we need to control concurrent access to the critical area, the basic to enjoy.
+
+111
+00:08:35,000 --> 00:08:37,000
+The key for this is synchronized keyword.
+
+112
+00:08:38,000 --> 00:08:40,000
+Let me open synchronized increment class.
+
+113
+00:08:41,000 --> 00:08:45,000
+This is similar example to the previous one was only one difference.
+
+114
+00:08:45,000 --> 00:08:48,000
+My increment method synchronized keyword here.
+
+115
+00:08:49,000 --> 00:08:51,000
+Let's run our program now multiple times.
+
+116
+00:08:51,000 --> 00:08:59,000
+And you can see now that I constantly have ten thousand and so is it is because this synchronized keyword
+
+117
+00:08:59,000 --> 00:09:03,000
+doesn't allow to stress access is block of code simultaneously.
+
+118
+00:09:04,000 --> 00:09:07,000
+That's why we just eliminated all possible errors.
+
+119
+00:09:07,000 --> 00:09:10,000
+How to synchronize keywords for X.
+
+120
+00:09:10,000 --> 00:09:14,000
+We need to understand this to create more complex solutions with better performance.
+
+121
+00:09:15,000 --> 00:09:21,000
+To understand how to synchronize keyboard works, we need to understand such important concepts in Montessori,
+
+122
+00:09:21,000 --> 00:09:24,000
+in programming as mutex and monitor.
+
+123
+00:09:24,000 --> 00:09:27,000
+Let's start from understanding of what Moneta is.
+
+124
+00:09:28,000 --> 00:09:33,000
+And once we learned what I wanted to ask, how explain the difference between the index and monitor
+
+125
+00:09:34,000 --> 00:09:36,000
+my own definition of monitor.
+
+126
+00:09:36,000 --> 00:09:42,000
+Sounds like this monitor is a mechanism to synchronize threads, access to critical sections.
+
+127
+00:09:43,000 --> 00:09:50,000
+More common definition from Wikipedia also includes other properties of monitor like ability to allow
+
+128
+00:09:50,000 --> 00:09:55,000
+stress to have both mutuel exclusion and the ability to wait for a critical condition.
+
+129
+00:09:56,000 --> 00:10:02,000
+By the way, mutuel exclusion is also churl from computer science and describes the property of.
+
+130
+00:10:02,000 --> 00:10:09,000
+Currency control, which should prevent a race condition by not allowing any threat, entering a political
+
+131
+00:10:09,000 --> 00:10:15,000
+section, if some as a threat currently executing the court of critical section somewhere, you married
+
+132
+00:10:15,000 --> 00:10:23,000
+another definition saying that monitor is a threat, safe class object or module that is partially also
+
+133
+00:10:23,000 --> 00:10:24,000
+makes sense.
+
+134
+00:10:24,000 --> 00:10:31,000
+We can use an object as a flag and as a monitor to indicate which threat captures and monitor of the
+
+135
+00:10:31,000 --> 00:10:34,000
+object and which threat released monitor of the object.
+
+136
+00:10:35,000 --> 00:10:39,000
+So injera monitor is implicitly associated with an object.
+
+137
+00:10:39,000 --> 00:10:42,000
+Let me support my explanation, which was analyzation.
+
+138
+00:10:43,000 --> 00:10:45,000
+Let's look at the example with my car.
+
+139
+00:10:45,000 --> 00:10:52,000
+Here is my only Rs5 that can reach 60 miles per hour in less than a three point five seconds.
+
+140
+00:10:52,000 --> 00:10:55,000
+This has nothing in common with multiscreen and yet.
+
+141
+00:10:55,000 --> 00:10:56,000
+But we will jump to the details.
+
+142
+00:10:56,000 --> 00:11:01,000
+So imagine that this car is a monitor and critical sections.
+
+143
+00:11:01,000 --> 00:11:06,000
+Here are accelerator pedal, brake pedal, steering wheel and so on.
+
+144
+00:11:07,000 --> 00:11:08,000
+I'm a threat.
+
+145
+00:11:09,000 --> 00:11:12,000
+And girlfriend of mine is another threat of execution.
+
+146
+00:11:13,000 --> 00:11:16,000
+Those threats can't simultaneously interact with.
+
+147
+00:11:17,000 --> 00:11:22,000
+It will be horrible sink in case me and your friend of mine will be pushing on different pedals simultaneously.
+
+148
+00:11:23,000 --> 00:11:27,000
+I can capture, monitor and do operations with the cars that they need.
+
+149
+00:11:28,000 --> 00:11:30,000
+I open the car and drive to an office.
+
+150
+00:11:30,000 --> 00:11:33,000
+And when I got back home, I released the monitor.
+
+151
+00:11:34,000 --> 00:11:40,000
+When the monitor is released and a threat, my girlfriend can take it and can go to the beauty salon,
+
+152
+00:11:40,000 --> 00:11:41,000
+for example.
+
+153
+00:11:41,000 --> 00:11:49,000
+Is it clear so far there are also some methods that allow to interact with, monitor their weight,
+
+154
+00:11:49,000 --> 00:11:51,000
+notify and notify all.
+
+155
+00:11:51,000 --> 00:11:52,000
+Wait.
+
+156
+00:11:52,000 --> 00:11:59,000
+MassArt is overloaded and has versions with arguments that time related arguments milliseconds and nanoseconds
+
+157
+00:12:00,000 --> 00:12:09,000
+zest masses inherited in all types from object class because all objects in Java implicitly extant object
+
+158
+00:12:09,000 --> 00:12:09,000
+class.
+
+159
+00:12:10,000 --> 00:12:11,000
+What these methods do.
+
+160
+00:12:12,000 --> 00:12:13,000
+Let's review an example.
+
+161
+00:12:14,000 --> 00:12:21,000
+Imagine that my girlfriend took a car and all of a sudden something happened with a car and it was stopped
+
+162
+00:12:21,000 --> 00:12:21,000
+unexpectedly.
+
+163
+00:12:22,000 --> 00:12:26,000
+She called me and asked me to pick up her with the car and help.
+
+164
+00:12:26,000 --> 00:12:32,000
+When I found her in the city, she went out of the car and let me in what she did.
+
+165
+00:12:32,000 --> 00:12:37,000
+She released more nature of the object temporarily and let me capture monitor.
+
+166
+00:12:38,000 --> 00:12:44,000
+She still has intention to drive further, but she just let me also perform some actions with the car.
+
+167
+00:12:44,000 --> 00:12:46,000
+And that is exactly what the weight method does.
+
+168
+00:12:46,000 --> 00:12:51,000
+It's just really this monitor and let us the capture monitor.
+
+169
+00:12:51,000 --> 00:12:57,000
+I was happy to discover that my girlfriend just didn't activate Immobiliser and the engine appeared
+
+170
+00:12:57,000 --> 00:12:58,000
+to be blocked.
+
+171
+00:12:58,000 --> 00:13:03,000
+I think that and told her that she can drive from wherever she needs.
+
+172
+00:13:03,000 --> 00:13:11,000
+What I did, I called notify Masset on the monitor, notify Masset makes all threats that we're waiting
+
+173
+00:13:11,000 --> 00:13:14,000
+are aware that they can proceed their work.
+
+174
+00:13:14,000 --> 00:13:21,000
+That means we use with Massata to let other threats perform some actions and modify the state of some
+
+175
+00:13:21,000 --> 00:13:24,000
+objects if needed, of some shared resources.
+
+176
+00:13:24,000 --> 00:13:31,000
+And after that, other threats should call notify Masset to update all threats that they've done.
+
+177
+00:13:32,000 --> 00:13:34,000
+Another example of wait and notify.
+
+178
+00:13:35,000 --> 00:13:39,000
+You're going to have coding exercises soon and there will be a task about readers and writers.
+
+179
+00:13:39,000 --> 00:13:46,000
+For example, readers interact with some buffer of memory where readers should find information to read
+
+180
+00:13:47,000 --> 00:13:52,000
+readers captions and monitor of buffer object and doesn't allow anyone to work with it.
+
+181
+00:13:53,000 --> 00:13:59,000
+Once readers read all information from Buffer and Buffer is empty, they're turned into the waiting
+
+182
+00:13:59,000 --> 00:14:04,000
+state and they wait until right to put your information into the buffer.
+
+183
+00:14:05,000 --> 00:14:11,000
+Once the writer finished its job and put all information and buffer it, notifies our readers that we're
+
+184
+00:14:11,000 --> 00:14:16,000
+in a weakened state by and notify all Masset on buffer object.
+
+185
+00:14:16,000 --> 00:14:20,000
+And now readers continue with information from Buffer and so on.
+
+186
+00:14:20,000 --> 00:14:27,000
+Notify all is a matter to notify not only once residents in waiting queue, but notify us all threats
+
+187
+00:14:27,000 --> 00:14:28,000
+that time in the waiting queue.
+
+188
+00:14:29,000 --> 00:14:33,000
+Hope that now you understood what is and wanted to know.
+
+189
+00:14:33,000 --> 00:14:38,000
+Let's understand the difference between two terms monitor and mutex.
+
+190
+00:14:38,000 --> 00:14:44,000
+Conceptually, these two terms are similar zooni difference is how they are implemented inside.
+
+191
+00:14:45,000 --> 00:14:52,000
+Usually the implementation of monitors is faster light weight since it is designed for multiple threaded
+
+192
+00:14:52,000 --> 00:14:54,000
+synchronization within the same process.
+
+193
+00:14:55,000 --> 00:15:01,000
+Also, usually it is provided by a framework library itself and not request the operating system.
+
+194
+00:15:01,000 --> 00:15:05,000
+Usually matrixes are provided by the operating system.
+
+195
+00:15:05,000 --> 00:15:12,000
+Kernell what is always Curnoe in simple words, it is a computer program at the core of the computer's
+
+196
+00:15:12,000 --> 00:15:16,000
+operating system and has complete control over everything in the system.
+
+197
+00:15:17,000 --> 00:15:21,000
+It also handles data processing instructions for the central processing unit.
+
+198
+00:15:22,000 --> 00:15:27,000
+It is a portion of the operating system code that is always resident in memory.
+
+199
+00:15:28,000 --> 00:15:33,000
+Usually libraries frameworks simply provide an interface to invoke mutex.
+
+200
+00:15:33,000 --> 00:15:40,000
+This makes them heavy weight slower, but allows us to achieve expected to result to synchronize threads
+
+201
+00:15:40,000 --> 00:15:42,000
+between each other and lock on.
+
+202
+00:15:42,000 --> 00:15:49,000
+Mutex from neutral exclusion is a mechanism that enforces limits on access to resource.
+
+203
+00:15:49,000 --> 00:15:55,000
+When there are many threats of execution, a lock is designed to enforce a mutual exclusion.
+
+204
+00:15:55,000 --> 00:16:01,000
+Concurrency Control Policy and Monitor consists of a mutex lock object and condition variables.
+
+205
+00:16:01,000 --> 00:16:07,000
+A condition variable essentially is a container of threats that are waiting for a certain condition
+
+206
+00:16:08,000 --> 00:16:08,000
+more.
+
+207
+00:16:08,000 --> 00:16:14,000
+Charters provide a mechanism for threats to temporarily give up exclusive access in order to wait for
+
+208
+00:16:14,000 --> 00:16:19,000
+some conditions to be met before gaining exclusive access and resuming their task.
+
+209
+00:16:20,000 --> 00:16:26,000
+So monitor is different than mutex, but they can be considered similar in the sense that the monitor
+
+210
+00:16:26,000 --> 00:16:31,000
+is built on top of mutex in this lesson we'll use to monitor transfers.
+
+211
+00:16:31,000 --> 00:16:36,000
+But just in case you heard that somebody uses mutex term, you'll really know the difference.
+
+212
+00:16:37,000 --> 00:16:43,000
+Now, let's look at the Korean example and we'll try to understand how monitor works, how synchronization
+
+213
+00:16:43,000 --> 00:16:47,000
+happens and practice example, a way to notify interaction.
+
+214
+00:16:47,000 --> 00:16:51,000
+Let's get back to synchronized examples that we already saw today.
+
+215
+00:16:51,000 --> 00:16:54,000
+There is one more method here that is similar to synchronized one.
+
+216
+00:16:55,000 --> 00:17:00,000
+Pay attention that this method doesn't have synchronized keywords in the same line was messed name,
+
+217
+00:17:00,000 --> 00:17:02,000
+but it contains synchronized block.
+
+218
+00:17:03,000 --> 00:17:03,000
+What is this?
+
+219
+00:17:04,000 --> 00:17:09,000
+So when you have synchronized Masad, it is fair to say that you captured the monitor of this object
+
+220
+00:17:10,000 --> 00:17:12,000
+of object which he used to Vogues and mastered.
+
+221
+00:17:13,000 --> 00:17:19,000
+But what object you used to walk in Inmarsat in this case and also how it works with static methods,
+
+222
+00:17:19,000 --> 00:17:21,000
+with static methods.
+
+223
+00:17:21,000 --> 00:17:25,000
+You capture Moneta of this class to create synchronized block.
+
+224
+00:17:25,000 --> 00:17:31,000
+You have to pass the reference to an object where you want to capture monitor right now.
+
+225
+00:17:31,000 --> 00:17:33,000
+And this block may enter only once read.
+
+226
+00:17:33,000 --> 00:17:40,000
+And once the threat will leave this block, it will release monitor of this class and the next threat
+
+227
+00:17:40,000 --> 00:17:45,000
+will enter this block and will capture monitor, of course, with synchronized methods.
+
+228
+00:17:45,000 --> 00:17:51,000
+That principle is the same, but you just have synchronized access to the whole method, and not only
+
+229
+00:17:51,000 --> 00:17:56,000
+for a specific part of it, why you might want to use synchronize blocks.
+
+230
+00:17:56,000 --> 00:18:02,000
+So this part of the spreading optimization, because it may be that actually not aligned in your methods
+
+231
+00:18:02,000 --> 00:18:04,000
+is a critical section.
+
+232
+00:18:04,000 --> 00:18:09,000
+Probably there are some operations that have multiple threads may perform in parallel.
+
+233
+00:18:09,000 --> 00:18:11,000
+That might be really different cases.
+
+234
+00:18:11,000 --> 00:18:16,000
+For example, here you will print some text to console or you just want to log that.
+
+235
+00:18:16,000 --> 00:18:22,000
+You enter this method and you want to log some message after critical section, or it can be some preparation
+
+236
+00:18:22,000 --> 00:18:24,000
+activities before the duration.
+
+237
+00:18:24,000 --> 00:18:27,000
+Anyway, log in print and text.
+
+238
+00:18:27,000 --> 00:18:30,000
+The console in this case is not a critical section.
+
+239
+00:18:30,000 --> 00:18:34,000
+This will not bring you to inconsistent state of your system.
+
+240
+00:18:34,000 --> 00:18:41,000
+That's why there is no need to make your threats, wait to do operations that they can do now without
+
+241
+00:18:41,000 --> 00:18:42,000
+waiting.
+
+242
+00:18:42,000 --> 00:18:47,000
+So all core outside of the synchronized block may be executed concurrently.
+
+243
+00:18:48,000 --> 00:18:54,000
+When you will create a certain program, always ask yourself, do I need to synchronize access to this
+
+244
+00:18:54,000 --> 00:19:00,000
+chunk of code or know what will happen if the threat will execute this code simultaneously?
+
+245
+00:19:00,000 --> 00:19:06,000
+And in case you discover that nothing bad would happen, do not with this code in synchronized lock,
+
+246
+00:19:07,000 --> 00:19:12,000
+because in this case you would improve performance of your app by not making your sweats.
+
+247
+00:19:12,000 --> 00:19:12,000
+Wait.
+
+248
+00:19:12,000 --> 00:19:19,000
+And when they shouldn't be waiting in general, this is rule of thumb to have a small synchronized block
+
+249
+00:19:19,000 --> 00:19:19,000
+as possible.
+
+250
+00:19:20,000 --> 00:19:25,000
+In case this method won't be static, you will capture monitor of another object.
+
+251
+00:19:25,000 --> 00:19:32,000
+In this case, you would capture monitor of this object, the one that invokes this method.
+
+252
+00:19:32,000 --> 00:19:34,000
+So these two methods now are similar.
+
+253
+00:19:35,000 --> 00:19:40,000
+What potential drawback you see in using synchronize locks with synchronized locks?
+
+254
+00:19:40,000 --> 00:19:45,000
+You can't capture a monitor in one place and release it completely in another place.
+
+255
+00:19:46,000 --> 00:19:52,000
+You can't describe synchronized lock in multiple methods, but there is so called a lock API that we
+
+256
+00:19:52,000 --> 00:19:54,000
+are going to learn all kinds.
+
+257
+00:19:54,000 --> 00:19:59,000
+Of course, that will allow you to capture more data in one place and release it somewhere else.
+
+258
+00:20:00,000 --> 00:20:06,000
+Now let's look at WAF not for example, I grouped all the classes related to this example in a separate
+
+259
+00:20:06,000 --> 00:20:06,000
+package.
+
+260
+00:20:06,000 --> 00:20:08,000
+Here was name with Latifi.
+
+261
+00:20:09,000 --> 00:20:14,000
+Let me open them a file and will start from one could imagine that I have some message.
+
+262
+00:20:14,000 --> 00:20:19,000
+I create object of this type and left some message to process it.
+
+263
+00:20:19,000 --> 00:20:25,000
+Let's have a look at the source code of message type message has one properties and describes its state.
+
+264
+00:20:26,000 --> 00:20:32,000
+It is called message and need this type fostering position because he already knows that string itself
+
+265
+00:20:32,000 --> 00:20:34,000
+immutable object.
+
+266
+00:20:34,000 --> 00:20:36,000
+Once a great object of type string.
+
+267
+00:20:36,000 --> 00:20:38,000
+I can't change it state.
+
+268
+00:20:39,000 --> 00:20:46,000
+That's why I created separate type that has API that allows me to update the state of the same object.
+
+269
+00:20:46,000 --> 00:20:48,000
+Also, there are two matters here.
+
+270
+00:20:48,000 --> 00:20:49,000
+Getter and setter.
+
+271
+00:20:50,000 --> 00:20:50,000
+That's it.
+
+272
+00:20:51,000 --> 00:20:52,000
+Let's get back to the demo file.
+
+273
+00:20:53,000 --> 00:20:56,000
+The second object that I create here is a reader object.
+
+274
+00:20:56,000 --> 00:20:58,000
+I pass a reference to the message object.
+
+275
+00:20:58,000 --> 00:20:59,000
+We are constructor.
+
+276
+00:21:00,000 --> 00:21:06,000
+After that I create a threat object based reference to the readers and name as threat as reader one
+
+277
+00:21:06,000 --> 00:21:07,000
+and start the threat.
+
+278
+00:21:08,000 --> 00:21:14,000
+Probably already understands its rather implements Runnable interface, and you're right where you source
+
+279
+00:21:14,000 --> 00:21:16,000
+code of reading type in a few seconds.
+
+280
+00:21:17,000 --> 00:21:19,000
+Also another reader and pay attention.
+
+281
+00:21:20,000 --> 00:21:22,000
+I pass the same message, object to the constructor.
+
+282
+00:21:23,000 --> 00:21:26,000
+This would be exactly the object that I would use for multiple threads.
+
+283
+00:21:26,000 --> 00:21:32,000
+Synchronization here I create another thread, object to his name reader to and run this thread.
+
+284
+00:21:33,000 --> 00:21:39,000
+So after this line we would have three threads running my main threat and to readers threats.
+
+285
+00:21:40,000 --> 00:21:44,000
+Let's learn what will be executed inside our readers around method.
+
+286
+00:21:45,000 --> 00:21:49,000
+As you can see, reader class implements Runnable Interface.
+
+287
+00:21:49,000 --> 00:21:50,000
+It has one property.
+
+288
+00:21:51,000 --> 00:21:58,000
+This is property of message type inside the one massive yet name of the thread for our demo purposes
+
+289
+00:21:58,000 --> 00:21:59,000
+to print its name to consult.
+
+290
+00:22:00,000 --> 00:22:02,000
+And after that I have synchronized S..
+
+291
+00:22:03,000 --> 00:22:09,000
+I didn't make synchronized maps because in this case all reader objects would have separate monitor
+
+292
+00:22:10,000 --> 00:22:11,000
+and need common monitoring.
+
+293
+00:22:11,000 --> 00:22:13,000
+There's a shared between two threats.
+
+294
+00:22:14,000 --> 00:22:20,000
+This is additional advantage of synchronized block because you can pass any object as a reference to
+
+295
+00:22:20,000 --> 00:22:21,000
+capture monitor.
+
+296
+00:22:22,000 --> 00:22:26,000
+And I have this massive object that is shared between two waiters.
+
+297
+00:22:26,000 --> 00:22:29,000
+So I kept your monitor off message object.
+
+298
+00:22:29,000 --> 00:22:37,000
+After that, I claim to cancel and indicate that this threat is waiting to be notified and Prince Current
+
+299
+00:22:37,000 --> 00:22:41,000
+milliseconds after that I go wait Masad on my message object.
+
+300
+00:22:41,000 --> 00:22:47,000
+One more important thing you can call way Massud only in specific context.
+
+301
+00:22:47,000 --> 00:22:53,000
+You can call this method only from synchronized sections and from synchronized methods in case you would
+
+302
+00:22:53,000 --> 00:22:54,000
+invoke weight.
+
+303
+00:22:54,000 --> 00:23:00,000
+Massive note in synchronized context, you will get runtime exception with name, illegal and interstate
+
+304
+00:23:00,000 --> 00:23:04,000
+exception because Red is not an owner of a monitor.
+
+305
+00:23:05,000 --> 00:23:11,000
+Once I call Weight Masset, this thread is in the waiting queue to proceed execution when it will be
+
+306
+00:23:11,000 --> 00:23:12,000
+notified.
+
+307
+00:23:12,000 --> 00:23:16,000
+At the same time, the second reader managed to enter this section.
+
+308
+00:23:16,000 --> 00:23:23,000
+Considering the first reader called Wait Masset on monitor, that means that the monitor is not blocked
+
+309
+00:23:23,000 --> 00:23:26,000
+and another reader can enter the section.
+
+310
+00:23:26,000 --> 00:23:29,000
+Now it is time to learn what is happening next.
+
+311
+00:23:29,000 --> 00:23:31,000
+Let's get back to our demo file.
+
+312
+00:23:31,000 --> 00:23:34,000
+Now it's time to create a notifier object.
+
+313
+00:23:34,000 --> 00:23:39,000
+Notifier type is my custom type that I also described in this package.
+
+314
+00:23:39,000 --> 00:23:43,000
+Pay attention that I pass the reference to the same message object.
+
+315
+00:23:43,000 --> 00:23:44,000
+Great.
+
+316
+00:23:44,000 --> 00:23:48,000
+A threat was named Notifier and started after that.
+
+317
+00:23:48,000 --> 00:23:49,000
+I printed all threads I started.
+
+318
+00:23:50,000 --> 00:23:52,000
+Let's investigate what this notified do.
+
+319
+00:23:52,000 --> 00:23:58,000
+As you can see, objects of this type also will store as a reference to the message object.
+
+320
+00:23:58,000 --> 00:23:59,000
+This is our monitor.
+
+321
+00:24:00,000 --> 00:24:07,000
+In one method we get the name of the threat and indicate that this threat started its work after Z,
+
+322
+00:24:07,000 --> 00:24:10,000
+I made this threat sleep for one hundred milliseconds.
+
+323
+00:24:10,000 --> 00:24:14,000
+This is to ensure that the reader objects captured monitor first.
+
+324
+00:24:14,000 --> 00:24:22,000
+Once the threat wakes up, I try to enter, synchronize the book and undo any other threat is captured
+
+325
+00:24:22,000 --> 00:24:23,000
+in message monitor.
+
+326
+00:24:23,000 --> 00:24:30,000
+All other threats, including this one will stay right before the critical section and would not enter
+
+327
+00:24:30,000 --> 00:24:34,000
+it until get notified from the threats that the monitor is released.
+
+328
+00:24:34,000 --> 00:24:37,000
+You remember that in other threats we invoked.
+
+329
+00:24:37,000 --> 00:24:38,000
+Wait Massett.
+
+330
+00:24:38,000 --> 00:24:43,000
+That means that Notifier may enter this section and capture Monisha.
+
+331
+00:24:43,000 --> 00:24:45,000
+In this critical section.
+
+332
+00:24:45,000 --> 00:24:47,000
+We perform message processing.
+
+333
+00:24:47,000 --> 00:24:51,000
+We change the text to indicate which Notifier updated the message.
+
+334
+00:24:51,000 --> 00:24:59,000
+And after that I invoke is to notify or notify all assets in case I would invoke notify massive on the
+
+335
+00:24:59,000 --> 00:25:01,000
+one threat will be notified.
+
+336
+00:25:01,000 --> 00:25:03,000
+Is a reader one or reader.
+
+337
+00:25:03,000 --> 00:25:04,000
+So let's check this.
+
+338
+00:25:05,000 --> 00:25:06,000
+I run them a file.
+
+339
+00:25:06,000 --> 00:25:11,000
+Here is a notification about we do once read started notify us.
+
+340
+00:25:11,000 --> 00:25:16,000
+Threats started here and we are to start started and waiting to get notified here at this time.
+
+341
+00:25:17,000 --> 00:25:22,000
+And once I called notify MassArt reader finished its execution.
+
+342
+00:25:22,000 --> 00:25:27,000
+So now you can see that we do one, get notified and read other one message.
+
+343
+00:25:27,000 --> 00:25:30,000
+Protest in the source code of reader class.
+
+344
+00:25:30,000 --> 00:25:36,000
+You can see that I print this text to console after wait Macit at the end of round method.
+
+345
+00:25:36,000 --> 00:25:39,000
+So often defecation all code that is below.
+
+346
+00:25:39,000 --> 00:25:41,000
+Wait Massata got executed.
+
+347
+00:25:41,000 --> 00:25:44,000
+Pay attention that our game isn't stopped yet.
+
+348
+00:25:44,000 --> 00:25:50,000
+You can see this red stop sign that tells us that I can stop game but it is run.
+
+349
+00:25:50,000 --> 00:25:53,000
+But why another idle threat is working now.
+
+350
+00:25:54,000 --> 00:25:56,000
+It actually does nothing at the moment.
+
+351
+00:25:56,000 --> 00:25:59,000
+It is just waiting to be notified in this line.
+
+352
+00:26:00,000 --> 00:26:05,000
+But only we know that there are no threats left in the app right now that would be able to notify us
+
+353
+00:26:05,000 --> 00:26:08,000
+with their object all as a threat.
+
+354
+00:26:08,000 --> 00:26:15,000
+I mean, the main threat with the one threat notifier already executed and finished, and this is the
+
+355
+00:26:15,000 --> 00:26:17,000
+last threat that is waiting right now.
+
+356
+00:26:17,000 --> 00:26:24,000
+Let me stop again if you know that such case may happen, in case you know that two more threats might
+
+357
+00:26:24,000 --> 00:26:30,000
+enter a critical section and wait until being notified, you should think about your multiscreen logic
+
+358
+00:26:30,000 --> 00:26:32,000
+very carefully to avoid cases like this.
+
+359
+00:26:33,000 --> 00:26:37,000
+One thread is waiting as low as a threat, always a threat.
+
+360
+00:26:37,000 --> 00:26:38,000
+How to figure this?
+
+361
+00:26:39,000 --> 00:26:45,000
+You should control how many times you call Wakamatsu and how many times you call notify Mass.
+
+362
+00:26:46,000 --> 00:26:53,000
+Considering we have one point in our app where we call notify MassArt in our single Notify Threat and
+
+363
+00:26:53,000 --> 00:26:55,000
+we have to either objects where we call with Macit.
+
+364
+00:26:56,000 --> 00:27:03,000
+Let's invoke notify all Massett in our notify I open, notify a class and will invoke notify all Masset
+
+365
+00:27:03,000 --> 00:27:05,000
+instead simply notify Mass.
+
+366
+00:27:06,000 --> 00:27:07,000
+Let's run our F one more time.
+
+367
+00:27:08,000 --> 00:27:13,000
+Now you can see that all threats finished their work and no other threats running.
+
+368
+00:27:14,000 --> 00:27:15,000
+We have both.
+
+369
+00:27:15,000 --> 00:27:17,000
+Neither one and we are to notify.
+
+370
+00:27:17,000 --> 00:27:22,000
+You can verify this when instigation of console output is clear.
+
+371
+00:27:22,000 --> 00:27:28,000
+It is great that now you know how to work with notified masses and synchronization basics.
+
+372
+00:27:28,000 --> 00:27:31,000
+Let's recap what we have learned in this lesson.
+
+373
+00:27:31,000 --> 00:27:34,000
+In this lesson we learned what critical section is.
+
+374
+00:27:35,000 --> 00:27:38,000
+You understood what atomic and atomic operations are.
+
+375
+00:27:39,000 --> 00:27:41,000
+And we are still going to learn with you.
+
+376
+00:27:41,000 --> 00:27:45,000
+Jabiri two concurrent atomic package in the next lessons.
+
+377
+00:27:45,000 --> 00:27:46,000
+So stay tuned.
+
+378
+00:27:47,000 --> 00:27:51,000
+Now, you know what monitor and mutex are and what is the difference between them?
+
+379
+00:27:51,000 --> 00:27:56,000
+Also, you know what a synchronized method and what a synchronized block.
+
+380
+00:27:56,000 --> 00:28:01,000
+And at the end of the lesson, we have learned what weight notify and notify all methods are.
+
+381
+00:28:02,000 --> 00:28:05,000
+That's all for today, hope you enjoyed this lesson.
+
+382
+00:28:06,000 --> 00:28:07,000
+Thank you for your attention.
+
+383
+00:28:07,000 --> 00:28:09,000
+See you in the next lesson.
+