IT & Mobile

콤비네이션(C) 알고리듬 참조:  http://stackoverflow.com/questions/2201113/combinatoric-n-choose-r-in-java-math 

int nCk = 1;
        for (int k = 0; k < K; k++) {
            System.out.print(nCk + " ");
            nCk = nCk * (n-k) / (k+1);
        }

예) 5C3 =   5/1 * 4/2 * 3/3  =  10..

중복 콤비네이션(H) 참조: https://ko.wikipedia.org/wiki/%EC%A1%B0%ED%95%A9 

    - 개의 빈칸에 중복을 허용하여 개의 원소를 넣는 개수로 생각할 수 있다.?

      즉, 개의 칸막이를 두고 가지 경우를 임의의 순서로 배열하는 것.?

      nHk = (n+k-1)C(n-1) = (n+k-1)Ck

spring에서 bean은 아무 생각없이 만들면

spring container에서 singleton 으로 만들어 준다.

(즉, 전체 sping container에서 항상 동일한 하나의 global instance로 bean을 만들어 준다)

따라서 immutable이고 status도 없이 만드는 것이 좋음.

만약, 다른 용도로 만드려면

Prototype Bean - 매번 생성

Session Bean  - WEB 세션별로 생성

Request  Bean - WEB Request별로 생성

이 존재하며..

@Component

@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)     과 같이 annotate 한다.

    - @Scope("prototype") 만 해도 되지만.. 위에 방식이 더 안전.

xml에서 할 경우에는
<baen id="note" class="my.Note" scope="prototype"> 으로 한다.

참고:  @Component는 autoscan이 되지만 @Bean의 경우에는 안되므로

@Bean을 직접 사용할 경우에는 method body에서 생성해서 return해야 한다.  REF

참고: java binarySearch예제

Comparator<Person> ageComparator = Comparator.comparingInt(Person::getAge);

int index = Arrays.binarySearch(people, new Person("Bob", 30), ageComparator);

(찾으면 >=0 못찾으면 -index-1 리턴)

아래는 없을땐 -1 리턴하는 java 코드들입니다.

<sort된 array내에서 exact매칭을 위한  BinSearch >

public int binSearch ( int A[],  int target ){

int low = 0;

int high = A.length -1;

int mid = 0;

while (low <= high ){

mid = (low+high)/2;

if       ( A[mid] < target)  low = mid+1;

else if ( A[mid] > target ) high = mid -1;

else 

return mid;

}

return -1;

}

<sort + rotate된 array내에서 exact매칭을 위한  BinSearch > 
예) [4,5,6,7,8, 0,1,2,3] 에서 target이 2인경우 ==> 정 답: 7

public int search(int[] nums, int target) {
        int low = 0;
        int high = nums.length - 1;
        int mid = 0;

        while (low <= high) {
            mid = (low + high) /2;
            
            if (nums[mid] == target) return mid;
            
            //left half sorted
            else if (nums[low] <= nums[mid] ) {
                //target이 left 존재 (mid제외)
                if (nums[low] <= target && nums[mid] > target) {
                    high = mid - 1;
                } 
                else low = mid + 1;
            }
            //right half sorted
            else {
                //target이 right에 존재 (mid 제외)
                if (nums[mid] < target && nums[high] >= target )
                    low = mid + 1;
                else
                    high = mid - 1;     
            }
        }
        return -1;
    }

<LE를  위한  BinSearch >  : LE - lessthan or Equal을 만족하는 최대 index 리턴.  

// A:{1,2,5, 9, 10}, target:7 =>   index:2 return이 목표.

public int binSearchLE ( int A[],  int target ){    

int low = 0;

int high = A.length -1;

int mid = 0;

while (low <= high) {

mid = (low+high)/2;

if       ( A[mid] < target)  low = mid+1;

else if ( A[mid] > target ) high = mid -1;

else 

return mid;

}

if ( mid>0 ) {   

if (A[mid] < target )    //LE CHeck

return mid;

if (A[mid] > target && A[mid-1] < target ) 

return mid-1; 

}

if (mid==0){  //mid가 0일경우는 어떡하나?

if (A[0] < target) return 0;

}

return -1;

}

   ======> 마지막 2개의 if를 간단히 3줄로도 줄일 수 있음.

if (arr[mid] < target) return mid;

else if (mid > 0 && arr[mid] > target && arr[mid-1] < target)
return mid -1;

//// low,high trace ///////////////////////

0,4 -> mid:2   if

3,4 -> mid:3   else_if

3,3 -> (mid:3) else_if

=> low,high가 마지막 loop이므로 이때 one more check가 필요. 

   return -1;  

<GE를  위한  BinSearch >  : GE - grea than or Equal을 만족하는 최소 index 리턴. 

// A:{1,2,5, 9, 10}, target:7 =>   index:3  return이 목표.

public int binSearchGE ( int A[],  int target ){    

int low = 0;

int high = A.length -1;

int mid = 0;

while (low <= high) {

mid = (low+high)/2;

if       ( A[mid] < target)  low = mid+1;

else if ( A[mid] > target ) high = mid -1;

else 

return mid;

}

if ( mid < A.length-1 ) {  

      if ( A[mid] < target &&  A[mid+1] > target ) 

return mid+1;

if  (A[mid] > target )  //GE CHeck

return mid;

 }

if (mid==A.length-1){  //?

if (A[mid] > target) 

return (A.length-1);

}

return -1;

}

//// low,high trace ///////////////////////

0,4 -> mid:2   if

3,4 -> mid:3   else_if

3,3 -> (mid:3) else_if

=> low,high가 마지막 loop이므로 이때 one more check가 필요. 

   return -1;  

java 에서  int 와 double이 default 이다.

따라서

long 이나, float를 선언할 때는 주의 해야 하는데

long sum =2147483648;     //에러

    =>  long sum=2147483648L;  //근데 작은값 들은 자동으로  문제 없는것 같긴 하다.

float f = 23.1

   => float f = 23.1f; 

로 고쳐주어야 한다. (L,f는 대소문자는 상관없다)

array의 경우도

float[] a = new float[] {-1.3f, -4.5f} ; //이런식으로 해야  컴파일 에러가 안난다.

< int +int => long>

  int a; int b; 

  a + b > c   하려면  a+ (long)b > c 로 해야지  좌변이 long으로 정확히 비교된다.

<참고사이트1>  <참고사이트2>

<메모리 분류>

  Young Gen  ( Eden ,  From, To)

  Old Gen  

  Perm Gen  :  static Object, Constant String,  Meta  가 저장되는데  GC가 되지 않는 영역이라서

                    메모리부족을 일으키는 요인 중 하나였는데,     JDK1.8 에서는 제거되었다..    Meta->native로,  static,String -> Heap으로 이동.

 <GC> minor GC 하다가 모자라면   Old로 promotion 하고.. 그래도 부족하면  Major GC or Full GC를 하게된다.

       1. minor GC (young GC) 가 할당된 survivor영역이 꽉차면 발생.

          Young Gen에서  unReferrence된  Object들을   GC하면서 

                => 비어있는 survivor영역으로 이동.  (공간부족시 Old영역으로 이동)

          from<->to 를 몇번(tenuringThreshold) 왔다갔다하면서도 살아남은 애들은 Old Gen 으로  옮긴다.
                                       

                                             CMS:Concurrent Mark & Sweep

        - Old GC (major GC) = parallel GC +  CMS GC + G1 GC  + (serial GC, parallel GC, parallel Comacting GC)  REF

           혹자는 Major GC=Full GC로 부르므로, 가능하면 Major GC란 용어는 사용하지 말자.

        2. Magor GC: 1 이후  CMS GC 가 일어나는데..
          CMS GC가  Old영역을 Compaction하지 않고 (즉, fragment를 해결하지 못하고) 따라서,  

          Full GC (전체 Heap clean) 를 유발: 즉, fragment가 많으면 Compaction(조각모음)도 수행한다.  ---> 이 때, STW 발생. '

                a. from, to 의 size를 늘이거나

                b. tenuringThreshold를 늘여서 old로 잘 안보내거나,  

                c. CMS 의 동작을 좀 빨리하도록 해서 compaction이 덜 일어나게 하거나??  (XX:CMSInitiatingOccupancyFraction)

          해서 해결한다. 

참고: Major GC vs Full GC - Full GC 는 전체 Heap을 clean .. Ref

        3.  old 나  Perm영역이 부족하면  Full GC가 일어나고, 
             이 대,  fragment가 많으면 Compaction(조각모음)도 수행한다.  ---> 이 때, STW 발생.         

                      혹자들(한국사이트들)은 old Generation이 꽉차면 이라고도 하는데.. 머 주로 compaction시 이것도 같이 발생할 것으로 보인다.

java 1.8 에서 permGen이 없어진 대신 metaSpace라는게 생겼다.
 metaSpace는 클래스Loader가 로드한 클래스들의 metaData과 관리되는 곳.
기존의 permGen은 Heap에서 관리했으나,  metaSpace는 native memory영역에서 관리함.
==> 그러므로 application이 STW할 확률은 낮아졌으나, OS전체 메모리가 부족할 수도 있으므로 --XXMetaSpace등으로 사이즈 조절필요.    참고: REF

참고사이트: http://www.scitech.co.kr/upload/book_image/s_017/Xml04.pdf 

<DTD>

 <!DOCTYPE Memo [

    <!ELEMENT Memo (PInfo, MInfo)>

    <!ELEMENT PInfo (from, to)>

    <!ELEMENT MInfo (date, main)>

    <!ELEMENT form (#PCDATA)>

    <!ELEMENT to (#PCDATA)>

    <!ELEMENT date (#PCDATA)>

    <!ELEMENT main (#PCDATA)>

]>

     DTD를 이용한 XML:  REF사이트

<XML XSD> : XML Schema Definition.

<?xml version="1.0" encoding="EUC-KR"?>

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"

targetNamespace="http://www.lisia.net"

xmlns="http://www.lisia.net"

elementFormDefault="qualified">

<xsd:element name="Memo">

 <xsd:complexType>  

  <xsd:sequence>

    <xsd:element name="PInfo">

    <xsd:complexType>

     <xsd:sequence>

       <xsd:element name="from type="xsd:string"/>

       <xsd:element name="to" type="xsd:string"/>

   </xsd:sequence>

==> XSD 를 이용한  XML   

<?xml version="1.0" encoding="EUC-KR"?>

<Memo xmlns="http://www.lisia.net" 

              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 

              xsi:schemaLocation="http://www.lisia.net ex4_3.xsd"> 

<PInfo>

     <from>김광수</from>

     <to>박수란</to>

</PInfo>

특성

1. immutable    (Array는 mutable)

2. recursive 지원 (Arrary는 미지원)

3. covariant  -   if S is subtype of T이면   List[S]도 List[T]의 subtype.

     =>  이로 인해, List() (List[Nothing])  이 List[S나 T]의 subtype 이 된다.

head와 tail

  - head는 첫 아이템이고 tail은 나머지 모든 아이템.

List 생성

 $ val abc: List[String] = List("a","b","c")

 $ val fruit = "ora" :: "pea" :: "apples" :: Nil     (이 경우에는 Nil이 꼭 필요)

패턴지정 (위에서 fruit가 지정되어 있는 경우)

 $ val List(a,b,c) = fruit     이런형태로 지정해서 a,b,c 를 자동 입력도 가능 (a="ora"가 됨)

:: (cons 연산자)

 - scala내의 class로도 존재하고, List내의 method로도 존재.

   (class로 존재하기 때문에  x :: xs 가 ::(x,xs) 로 취급됨.

scala 싱글턴 Object  (즉, 키워드 object)

는 2가지 용도로 쓰인다.

1.  Companion Object

- scala class에는 static 함수를 포함할 수 없기 때문에, class 와 동일한 Object 이름을 이용해서

static 함수를 모아 놓는다. 

class A(msg:String){

   def greet() = println(msg)

}

object A{

  def trim(s:String) = s..blabla

}

2. stand-alone Object.    

 - 이건 제일 자주보는 main을 포함하기 위한 용도이다.

object myApp {

  def main( args: Array[String]) {

  }

}

1. Nil은  List 가   비어있을 때.를 Nil이라고 한다.

$ val a=List()

$ a==Nil      ==>    true 임.

2. Nothing은 최하위 class 이다.  

  아래 예제에서 else 경우에 Nothing이 리턴된다. (Int 의 Subtype이므로 리턴 가능.) 

  def divide(x:Int, y:Int) :Int =  if (y!=0) x/y  else error("hi Error")

    =>  이경우에 Nothing이...   인터프리터에서 돌려보니 deprecation 된 거 같기도 한데.. (추가 확인 필요) 

3. Null은 기존 java Null 하고 비슷하니 개념은 잠시 잊어도 되겠다.

<Hierarchy>

java.lang.Object 에 해당하는 건  scala.AnyRef 이다.

Scala에선 Any가 최상위 클래스 이고..

data Type 들은 왼쪽 AnyVal 트리를 타게 되므로..

아래 계층도와 같다.

            Any

          /     |    

AnyVal   AnyRef

      |         |

Type들    AnyObject

      |         |

      |       Null 

      |        /

     Nothing

 ($: scala line interpreter 라고 치고.....)

기본 def:

$def h(x:String):Type = { println(x)}

1. 한 줄 일때는 curly brace 생략 가능

$def  h() = println("hi")

$def  h = println("hi")    (이것도 동일 동작.)

  => 이 때 아무동작 안하는 듯한 return type은 Unit이라고 부름 (java 의 void 와 비슷)

2. retrurn Type은 보통 안 붙여도 자동추론 하지만. recursive일 때는 꼭 필요.

3. def this     :    추가 생성자용도이다.   (overloaded constructor or Auxilary constructor 라고 부른다) 

   primary 생성자는 자동생성되므로..아래 예제처럼 추가 생성자를 생성할때  this함수와 함께 사용할 수 있다.

 class Test( msg:String, count:Int) {

    def this (msg:String ) = this (msg,1)

 }